/// <reference path="./gsk-4.0.d.ts" />
/// <reference path="./graphene-1.0.d.ts" />
/// <reference path="./gobject-2.0.d.ts" />
/// <reference path="./glib-2.0.d.ts" />
/// <reference path="./gdk-4.0.d.ts" />
/// <reference path="./cairo-1.0.d.ts" />
/// <reference path="./cairo.d.ts" />
/// <reference path="./pangocairo-1.0.d.ts" />
/// <reference path="./pango-1.0.d.ts" />
/// <reference path="./harfbuzz-0.0.d.ts" />
/// <reference path="./freetype2-2.0.d.ts" />
/// <reference path="./gio-2.0.d.ts" />
/// <reference path="./gmodule-2.0.d.ts" />
/// <reference path="./gdkpixbuf-2.0.d.ts" />

/**
 * Type Definitions for Gjs (https://gjs.guide/)
 *
 * These type definitions are automatically generated, do not edit them by hand.
 * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
 *
 * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
 */

declare module 'gi://Gtk?version=4.0' {
    // Module dependencies
    import type Gsk from 'gi://Gsk?version=4.0';
    import type Graphene from 'gi://Graphene?version=1.0';
    import type GObject from 'gi://GObject?version=2.0';
    import type GLib from 'gi://GLib?version=2.0';
    import type Gdk from 'gi://Gdk?version=4.0';
    import type cairo from 'cairo';
    import type PangoCairo from 'gi://PangoCairo?version=1.0';
    import type Pango from 'gi://Pango?version=1.0';
    import type HarfBuzz from 'gi://HarfBuzz?version=0.0';
    import type freetype2 from 'gi://freetype2?version=2.0';
    import type Gio from 'gi://Gio?version=2.0';
    import type GModule from 'gi://GModule?version=2.0';
    import type GdkPixbuf from 'gi://GdkPixbuf?version=2.0';

    export namespace Gtk {
        /**
         * Gtk-4.0
         */

        /**
         * The priority of an accessibility announcement.
         */

        /**
         * The priority of an accessibility announcement.
         */
        export namespace AccessibleAnnouncementPriority {
            export const $gtype: GObject.GType<AccessibleAnnouncementPriority>;
        }

        enum AccessibleAnnouncementPriority {
            /**
             * The announcement is low priority,
             *   and might be read only on the user's request.
             */
            LOW,
            /**
             * The announcement is of medium
             *   priority, and is usually spoken at the next opportunity, such as at the
             *   end of speaking the current sentence or when the user pauses typing.
             */
            MEDIUM,
            /**
             * The announcement is of high
             *   priority, and is usually spoken immediately. Because an interruption
             *   might disorient users or cause them to not complete their current task,
             *   authors SHOULD NOT use high priority announcements unless the
             *   interruption is imperative. An example would be a notification about a
             *   critical battery power level.
             */
            HIGH,
        }
        /**
         * The possible values for the %GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE
         * accessible property.
         */

        /**
         * The possible values for the %GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE
         * accessible property.
         */
        export namespace AccessibleAutocomplete {
            export const $gtype: GObject.GType<AccessibleAutocomplete>;
        }

        enum AccessibleAutocomplete {
            /**
             * Automatic suggestions are not displayed.
             */
            NONE,
            /**
             * When a user is providing input, text
             *    suggesting one way to complete the provided input may be dynamically
             *    inserted after the caret.
             */
            INLINE,
            /**
             * When a user is providing input, an element
             *    containing a collection of values that could complete the provided input
             *    may be displayed.
             */
            LIST,
            /**
             * When a user is providing input, an element
             *    containing a collection of values that could complete the provided input
             *    may be displayed. If displayed, one value in the collection is automatically
             *    selected, and the text needed to complete the automatically selected value
             *    appears after the caret in the input.
             */
            BOTH,
        }
        /**
         * The possible values for the %GTK_ACCESSIBLE_STATE_INVALID
         * accessible state.
         *
         * Note that the %GTK_ACCESSIBLE_INVALID_FALSE and
         * %GTK_ACCESSIBLE_INVALID_TRUE have the same values
         * as %FALSE and %TRUE.
         */

        /**
         * The possible values for the %GTK_ACCESSIBLE_STATE_INVALID
         * accessible state.
         *
         * Note that the %GTK_ACCESSIBLE_INVALID_FALSE and
         * %GTK_ACCESSIBLE_INVALID_TRUE have the same values
         * as %FALSE and %TRUE.
         */
        export namespace AccessibleInvalidState {
            export const $gtype: GObject.GType<AccessibleInvalidState>;
        }

        enum AccessibleInvalidState {
            /**
             * There are no detected errors in the value
             */
            FALSE,
            /**
             * The value entered by the user has failed validation
             */
            TRUE,
            /**
             * A grammatical error was detected
             */
            GRAMMAR,
            /**
             * A spelling error was detected
             */
            SPELLING,
        }
        /**
         * The various platform states which can be queried
         * using [method`Gtk`.Accessible.get_platform_state].
         */

        /**
         * The various platform states which can be queried
         * using [method`Gtk`.Accessible.get_platform_state].
         */
        export namespace AccessiblePlatformState {
            export const $gtype: GObject.GType<AccessiblePlatformState>;
        }

        enum AccessiblePlatformState {
            /**
             * whether the accessible can be focused
             */
            FOCUSABLE,
            /**
             * whether the accessible has focus
             */
            FOCUSED,
            /**
             * whether the accessible is active
             */
            ACTIVE,
        }
        /**
         * The possible accessible properties of a [iface`Accessible]`.
         */

        /**
         * The possible accessible properties of a [iface`Accessible]`.
         */
        export namespace AccessibleProperty {
            export const $gtype: GObject.GType<AccessibleProperty>;
        }

        enum AccessibleProperty {
            /**
             * Indicates whether inputting text
             *    could trigger display of one or more predictions of the user's intended
             *    value for a combobox, searchbox, or textbox and specifies how predictions
             *    would be presented if they were made. Value type: [enum`AccessibleAutocomplete]`
             */
            AUTOCOMPLETE,
            /**
             * Defines a string value that describes
             *    or annotates the current element. Value type: string
             */
            DESCRIPTION,
            /**
             * Indicates the availability and type of
             *    interactive popup element, such as menu or dialog, that can be triggered
             *    by an element.
             */
            HAS_POPUP,
            /**
             * Indicates keyboard shortcuts that an
             *    author has implemented to activate or give focus to an element. Value type:
             *    string
             */
            KEY_SHORTCUTS,
            /**
             * Defines a string value that labels the current
             *    element. Value type: string
             */
            LABEL,
            /**
             * Defines the hierarchical level of an element
             *    within a structure. Value type: integer
             */
            LEVEL,
            /**
             * Indicates whether an element is modal when
             *    displayed. Value type: boolean
             */
            MODAL,
            /**
             * Indicates whether a text box accepts
             *    multiple lines of input or only a single line. Value type: boolean
             */
            MULTI_LINE,
            /**
             * Indicates that the user may select
             *    more than one item from the current selectable descendants. Value type:
             *    boolean
             */
            MULTI_SELECTABLE,
            /**
             * Indicates whether the element's
             *    orientation is horizontal, vertical, or unknown/ambiguous. Value type:
             *    [enum`Orientation]`
             */
            ORIENTATION,
            /**
             * Defines a short hint (a word or short
             *    phrase) intended to aid the user with data entry when the control has no
             *    value. A hint could be a sample value or a brief description of the expected
             *    format. Value type: string
             */
            PLACEHOLDER,
            /**
             * Indicates that the element is not editable,
             *    but is otherwise operable. Value type: boolean
             */
            READ_ONLY,
            /**
             * Indicates that user input is required on
             *    the element before a form may be submitted. Value type: boolean
             */
            REQUIRED,
            /**
             * Defines a human-readable,
             *    author-localized description for the role of an element. Value type: string
             */
            ROLE_DESCRIPTION,
            /**
             * Indicates if items in a table or grid are
             *    sorted in ascending or descending order. Value type: [enum`AccessibleSort]`
             */
            SORT,
            /**
             * Defines the maximum allowed value for a
             *    range widget. Value type: double
             */
            VALUE_MAX,
            /**
             * Defines the minimum allowed value for a
             *    range widget. Value type: double
             */
            VALUE_MIN,
            /**
             * Defines the current value for a range widget.
             *    Value type: double
             */
            VALUE_NOW,
            /**
             * Defines the human readable text alternative
             *    of aria-valuenow for a range widget. Value type: string
             */
            VALUE_TEXT,
            /**
             * Defines a string value that provides a description of non-standard keyboard
             * interactions of the current element. Value type: string
             */
            HELP_TEXT,
        }
        /**
         * The possible accessible relations of a [iface`Accessible]`.
         *
         * Accessible relations can be references to other widgets,
         * integers or strings.
         */

        /**
         * The possible accessible relations of a [iface`Accessible]`.
         *
         * Accessible relations can be references to other widgets,
         * integers or strings.
         */
        export namespace AccessibleRelation {
            export const $gtype: GObject.GType<AccessibleRelation>;
        }

        enum AccessibleRelation {
            /**
             * Identifies the currently active
             *    element when focus is on a composite widget, combobox, textbox, group,
             *    or application. Value type: reference
             */
            ACTIVE_DESCENDANT,
            /**
             * Defines the total number of columns
             *    in a table, grid, or treegrid. Value type: integer
             */
            COL_COUNT,
            /**
             * Defines an element's column index or
             *    position with respect to the total number of columns within a table,
             *    grid, or treegrid. Value type: integer
             */
            COL_INDEX,
            /**
             * Defines a human readable text
             *   alternative of %GTK_ACCESSIBLE_RELATION_COL_INDEX. Value type: string
             */
            COL_INDEX_TEXT,
            /**
             * Defines the number of columns spanned
             *   by a cell or gridcell within a table, grid, or treegrid. Value type: integer
             */
            COL_SPAN,
            /**
             * Identifies the element (or elements) whose
             *    contents or presence are controlled by the current element. Value type: reference
             */
            CONTROLS,
            /**
             * Identifies the element (or elements)
             *    that describes the object. Value type: reference
             */
            DESCRIBED_BY,
            /**
             * Identifies the element (or elements) that
             *    provide additional information related to the object. Value type: reference
             */
            DETAILS,
            /**
             * Identifies the element (or elements) that
             *    provide an error message for an object. Value type: reference
             */
            ERROR_MESSAGE,
            /**
             * Identifies the next element (or elements)
             *    in an alternate reading order of content which, at the user's discretion,
             *    allows assistive technology to override the general default of reading in
             *    document source order. Value type: reference
             */
            FLOW_TO,
            /**
             * Identifies the element (or elements)
             *    that labels the current element. Value type: reference
             */
            LABELLED_BY,
            /**
             * Identifies an element (or elements) in order
             *    to define a visual, functional, or contextual parent/child relationship
             *    between elements where the widget hierarchy cannot be used to represent
             *    the relationship. Value type: reference
             */
            OWNS,
            /**
             * Defines an element's number or position
             *    in the current set of listitems or treeitems. Value type: integer
             */
            POS_IN_SET,
            /**
             * Defines the total number of rows in a table,
             *    grid, or treegrid. Value type: integer
             */
            ROW_COUNT,
            /**
             * Defines an element's row index or position
             *    with respect to the total number of rows within a table, grid, or treegrid.
             *    Value type: integer
             */
            ROW_INDEX,
            /**
             * Defines a human readable text
             *    alternative of aria-rowindex. Value type: string
             */
            ROW_INDEX_TEXT,
            /**
             * Defines the number of rows spanned by a
             *    cell or gridcell within a table, grid, or treegrid. Value type: integer
             */
            ROW_SPAN,
            /**
             * Defines the number of items in the current
             *    set of listitems or treeitems. Value type: integer
             */
            SET_SIZE,
        }
        /**
         * The accessible role for a [iface`Accessible]` implementation.
         *
         * Abstract roles are only used as part of the ontology; application
         * developers must not use abstract roles in their code.
         */

        /**
         * The accessible role for a [iface`Accessible]` implementation.
         *
         * Abstract roles are only used as part of the ontology; application
         * developers must not use abstract roles in their code.
         */
        export namespace AccessibleRole {
            export const $gtype: GObject.GType<AccessibleRole>;
        }

        enum AccessibleRole {
            /**
             * An element with important, and usually
             *   time-sensitive, information
             */
            ALERT,
            /**
             * A type of dialog that contains an
             *   alert message
             */
            ALERT_DIALOG,
            /**
             * Unused
             */
            BANNER,
            /**
             * An input element that allows for
             *   user-triggered actions when clicked or pressed
             */
            BUTTON,
            /**
             * Unused
             */
            CAPTION,
            /**
             * Unused
             */
            CELL,
            /**
             * A checkable input element that has
             *   three possible values: `true`, `false`, or `mixed`
             */
            CHECKBOX,
            /**
             * A header in a columned list.
             */
            COLUMN_HEADER,
            /**
             * An input that controls another element,
             *   such as a list or a grid, that can dynamically pop up to help the user
             *   set the value of the input
             */
            COMBO_BOX,
            /**
             * Abstract role.
             */
            COMMAND,
            /**
             * Abstract role.
             */
            COMPOSITE,
            /**
             * A dialog is a window that is designed to interrupt
             *   the current processing of an application in order to prompt the user to enter
             *   information or require a response.
             */
            DIALOG,
            /**
             * Content that assistive technology users may want to
             *   browse in a reading mode.
             */
            DOCUMENT,
            /**
             * Unused
             */
            FEED,
            /**
             * Unused
             */
            FORM,
            /**
             * A nameless container that has no semantic meaning
             *   of its own. This is the role that GTK uses by default for widgets.
             */
            GENERIC,
            /**
             * A grid of items.
             */
            GRID,
            /**
             * An item in a grid or tree grid.
             */
            GRID_CELL,
            /**
             * An element that groups multiple related widgets. GTK uses
             *   this role for various containers, like [class`Gtk`.HeaderBar] or [class`Gtk`.Notebook].
             */
            GROUP,
            /**
             * Unused
             */
            HEADING,
            /**
             * An image.
             */
            IMG,
            /**
             * Abstract role.
             */
            INPUT,
            /**
             * A visible name or caption for a user interface component.
             */
            LABEL,
            /**
             * Abstract role.
             */
            LANDMARK,
            /**
             * Unused
             */
            LEGEND,
            /**
             * A clickable link.
             */
            LINK,
            /**
             * A list of items.
             */
            LIST,
            /**
             * Unused.
             */
            LIST_BOX,
            /**
             * An item in a list.
             */
            LIST_ITEM,
            /**
             * Unused
             */
            LOG,
            /**
             * Unused
             */
            MAIN,
            /**
             * Unused
             */
            MARQUEE,
            /**
             * Unused
             */
            MATH,
            /**
             * An element that represents a value within a known range.
             */
            METER,
            /**
             * A menu.
             */
            MENU,
            /**
             * A menubar.
             */
            MENU_BAR,
            /**
             * An item in a menu.
             */
            MENU_ITEM,
            /**
             * A check item in a menu.
             */
            MENU_ITEM_CHECKBOX,
            /**
             * A radio item in a menu.
             */
            MENU_ITEM_RADIO,
            /**
             * Unused
             */
            NAVIGATION,
            /**
             * An element that is not represented to accessibility technologies.
             *   This role is synonymous to `GTK_ACCESSIBLE_ROLE_PRESENTATION`.
             */
            NONE,
            /**
             * Unused
             */
            NOTE,
            /**
             * Unused
             */
            OPTION,
            /**
             * An element that is not represented to accessibility technologies.
             *   This role is synonymous to `GTK_ACCESSIBLE_ROLE_NONE`.
             */
            PRESENTATION,
            /**
             * An element that displays the progress
             *   status for tasks that take a long time.
             */
            PROGRESS_BAR,
            /**
             * A checkable input in a group of radio roles,
             *   only one of which can be checked at a time.
             */
            RADIO,
            /**
             * Unused
             */
            RADIO_GROUP,
            /**
             * Abstract role.
             */
            RANGE,
            /**
             * Unused
             */
            REGION,
            /**
             * A row in a columned list.
             */
            ROW,
            /**
             * Unused
             */
            ROW_GROUP,
            /**
             * Unused
             */
            ROW_HEADER,
            /**
             * A graphical object that controls the scrolling
             *   of content within a viewing area, regardless of whether the content is fully
             *   displayed within the viewing area.
             */
            SCROLLBAR,
            /**
             * Unused
             */
            SEARCH,
            /**
             * A type of textbox intended for specifying
             *   search criteria.
             */
            SEARCH_BOX,
            /**
             * Abstract role.
             */
            SECTION,
            /**
             * Abstract role.
             */
            SECTION_HEAD,
            /**
             * Abstract role.
             */
            SELECT,
            /**
             * A divider that separates and distinguishes
             *   sections of content or groups of menuitems.
             */
            SEPARATOR,
            /**
             * A user input where the user selects a value
             *   from within a given range.
             */
            SLIDER,
            /**
             * A form of range that expects the user to
             *   select from among discrete choices.
             */
            SPIN_BUTTON,
            /**
             * Unused
             */
            STATUS,
            /**
             * Abstract role.
             */
            STRUCTURE,
            /**
             * A type of checkbox that represents on/off values,
             *   as opposed to checked/unchecked values.
             */
            SWITCH,
            /**
             * An item in a list of tab used for switching pages.
             */
            TAB,
            /**
             * Unused
             */
            TABLE,
            /**
             * A list of tabs for switching pages.
             */
            TAB_LIST,
            /**
             * A page in a notebook or stack.
             */
            TAB_PANEL,
            /**
             * A type of input that allows free-form text
             *   as its value.
             */
            TEXT_BOX,
            /**
             * Unused
             */
            TIME,
            /**
             * Unused
             */
            TIMER,
            /**
             * Unused
             */
            TOOLBAR,
            /**
             * Unused
             */
            TOOLTIP,
            /**
             * Unused
             */
            TREE,
            /**
             * A treeview-like, columned list.
             */
            TREE_GRID,
            /**
             * Unused
             */
            TREE_ITEM,
            /**
             * Abstract role for interactive components of a
             *   graphical user interface
             */
            WIDGET,
            /**
             * Abstract role for windows.
             */
            WINDOW,
            /**
             * A type of push button which stays pressed until depressed by a second
             * activation.
             */
            TOGGLE_BUTTON,
            /**
             * A toplevel element of a graphical user interface.
             *
             * This is the role that GTK uses by default for windows.
             */
            APPLICATION,
            /**
             * A paragraph of content.
             */
            PARAGRAPH,
            /**
             * A section of content that is quoted from another source.
             */
            BLOCK_QUOTE,
            /**
             * A section of a page that consists of a composition that forms an independent
             * part of a document, page, or site.
             */
            ARTICLE,
            /**
             * A comment contains content expressing reaction to other content.
             */
            COMMENT,
            /**
             * A virtual terminal.
             */
            TERMINAL,
        }
        /**
         * The possible values for the %GTK_ACCESSIBLE_PROPERTY_SORT
         * accessible property.
         */

        /**
         * The possible values for the %GTK_ACCESSIBLE_PROPERTY_SORT
         * accessible property.
         */
        export namespace AccessibleSort {
            export const $gtype: GObject.GType<AccessibleSort>;
        }

        enum AccessibleSort {
            /**
             * There is no defined sort applied to the column.
             */
            NONE,
            /**
             * Items are sorted in ascending order by this column.
             */
            ASCENDING,
            /**
             * Items are sorted in descending order by this column.
             */
            DESCENDING,
            /**
             * A sort algorithm other than ascending or
             *    descending has been applied.
             */
            OTHER,
        }
        /**
         * The possible accessible states of a [iface`Accessible]`.
         */

        /**
         * The possible accessible states of a [iface`Accessible]`.
         */
        export namespace AccessibleState {
            export const $gtype: GObject.GType<AccessibleState>;
        }

        enum AccessibleState {
            /**
             * A “busy” state. This state has boolean values
             */
            BUSY,
            /**
             * A “checked” state; indicates the current
             *   state of a [class`CheckButton]`. Value type: [enum`AccessibleTristate]`
             */
            CHECKED,
            /**
             * A “disabled” state; corresponds to the
             *   [property`Widget:`sensitive] property. It indicates a UI element
             *   that is perceivable, but not editable or operable. Value type: boolean
             */
            DISABLED,
            /**
             * An “expanded” state; corresponds to the
             *   [property`Expander:`expanded] property. Value type: boolean
             *   or undefined
             */
            EXPANDED,
            /**
             * A “hidden” state; corresponds to the
             *   [property`Widget:`visible] property. You can use this state
             *   explicitly on UI elements that should not be exposed to an assistive
             *   technology. Value type: boolean
             *   See also: %GTK_ACCESSIBLE_STATE_DISABLED
             */
            HIDDEN,
            /**
             * An “invalid” state; set when a widget
             *   is showing an error. Value type: [enum`AccessibleInvalidState]`
             */
            INVALID,
            /**
             * A “pressed” state; indicates the current
             *   state of a [class`ToggleButton]`. Value type: [enum`AccessibleTristate]`
             *   enumeration
             */
            PRESSED,
            /**
             * A “selected” state; set when a widget
             *   is selected. Value type: boolean or undefined
             */
            SELECTED,
            /**
             * Indicates that a widget with the GTK_ACCESSIBLE_ROLE_LINK has been visited.
             * Value type: boolean.
             */
            VISITED,
        }
        /**
         * The type of contents change operation.
         */

        /**
         * The type of contents change operation.
         */
        export namespace AccessibleTextContentChange {
            export const $gtype: GObject.GType<AccessibleTextContentChange>;
        }

        enum AccessibleTextContentChange {
            /**
             * contents change as the result of
             *   an insert operation
             */
            INSERT,
            /**
             * contents change as the result of
             *   a remove operation
             */
            REMOVE,
        }
        /**
         * The granularity for queries about the text contents of a [iface`Gtk`.AccessibleText]
         * implementation.
         */

        /**
         * The granularity for queries about the text contents of a [iface`Gtk`.AccessibleText]
         * implementation.
         */
        export namespace AccessibleTextGranularity {
            export const $gtype: GObject.GType<AccessibleTextGranularity>;
        }

        enum AccessibleTextGranularity {
            /**
             * Use the boundary between
             *   characters (including non-printing characters)
             */
            CHARACTER,
            /**
             * Use the boundary between words,
             *   starting from the beginning of the current word and ending at the
             *   beginning of the next word
             */
            WORD,
            /**
             * Use the boundary between
             *   sentences, starting from the beginning of the current sentence and
             *   ending at the beginning of the next sentence
             */
            SENTENCE,
            /**
             * Use the boundary between lines,
             *   starting from the beginning of the current line and ending at the
             *   beginning of the next line
             */
            LINE,
            /**
             * Use the boundary between
             *   paragraphs, starting from the beginning of the current paragraph and
             *   ending at the beginning of the next paragraph
             */
            PARAGRAPH,
        }
        /**
         * The possible values for the %GTK_ACCESSIBLE_STATE_PRESSED
         * accessible state.
         *
         * Note that the %GTK_ACCESSIBLE_TRISTATE_FALSE and
         * %GTK_ACCESSIBLE_TRISTATE_TRUE have the same values
         * as %FALSE and %TRUE.
         */

        /**
         * The possible values for the %GTK_ACCESSIBLE_STATE_PRESSED
         * accessible state.
         *
         * Note that the %GTK_ACCESSIBLE_TRISTATE_FALSE and
         * %GTK_ACCESSIBLE_TRISTATE_TRUE have the same values
         * as %FALSE and %TRUE.
         */
        export namespace AccessibleTristate {
            export const $gtype: GObject.GType<AccessibleTristate>;
        }

        enum AccessibleTristate {
            /**
             * The state is `false`
             */
            FALSE,
            /**
             * The state is `true`
             */
            TRUE,
            /**
             * The state is `mixed`
             */
            MIXED,
        }
        /**
         * Controls how a widget deals with extra space in a single dimension.
         *
         * Alignment only matters if the widget receives a “too large” allocation,
         * for example if you packed the widget with the [property`Gtk`.Widget:hexpand]
         * property inside a [class`Box]`, then the widget might get extra space.
         * If you have for example a 16x16 icon inside a 32x32 space, the icon
         * could be scaled and stretched, it could be centered, or it could be
         * positioned to one side of the space.
         *
         * Note that in horizontal context `GTK_ALIGN_START` and `GTK_ALIGN_END`
         * are interpreted relative to text direction.
         *
         * Baseline support is optional for containers and widgets, and is only available
         * for vertical alignment. `GTK_ALIGN_BASELINE_CENTER` and `GTK_ALIGN_BASELINE_FILL`
         * are treated similar to `GTK_ALIGN_CENTER` and `GTK_ALIGN_FILL`, except that it
         * positions the widget to line up the baselines, where that is supported.
         */

        /**
         * Controls how a widget deals with extra space in a single dimension.
         *
         * Alignment only matters if the widget receives a “too large” allocation,
         * for example if you packed the widget with the [property`Gtk`.Widget:hexpand]
         * property inside a [class`Box]`, then the widget might get extra space.
         * If you have for example a 16x16 icon inside a 32x32 space, the icon
         * could be scaled and stretched, it could be centered, or it could be
         * positioned to one side of the space.
         *
         * Note that in horizontal context `GTK_ALIGN_START` and `GTK_ALIGN_END`
         * are interpreted relative to text direction.
         *
         * Baseline support is optional for containers and widgets, and is only available
         * for vertical alignment. `GTK_ALIGN_BASELINE_CENTER` and `GTK_ALIGN_BASELINE_FILL`
         * are treated similar to `GTK_ALIGN_CENTER` and `GTK_ALIGN_FILL`, except that it
         * positions the widget to line up the baselines, where that is supported.
         */
        export namespace Align {
            export const $gtype: GObject.GType<Align>;
        }

        enum Align {
            /**
             * stretch to fill all space if possible, center if
             *   no meaningful way to stretch
             */
            FILL,
            /**
             * snap to left or top side, leaving space on right or bottom
             */
            START,
            /**
             * snap to right or bottom side, leaving space on left or top
             */
            END,
            /**
             * center natural width of widget inside the allocation
             */
            CENTER,
            /**
             * a different name for `GTK_ALIGN_BASELINE`.
             */
            BASELINE_FILL,
            /**
             * align the widget according to the baseline.
             */
            BASELINE,
            /**
             * stretch to fill all space, but align the baseline.
             */
            BASELINE_CENTER,
        }
        /**
         * Used to indicate the direction in which an arrow should point.
         */

        /**
         * Used to indicate the direction in which an arrow should point.
         */
        export namespace ArrowType {
            export const $gtype: GObject.GType<ArrowType>;
        }

        enum ArrowType {
            /**
             * Represents an upward pointing arrow.
             */
            UP,
            /**
             * Represents a downward pointing arrow.
             */
            DOWN,
            /**
             * Represents a left pointing arrow.
             */
            LEFT,
            /**
             * Represents a right pointing arrow.
             */
            RIGHT,
            /**
             * No arrow.
             */
            NONE,
        }
        /**
         * Determines the page role inside a `GtkAssistant`.
         *
         * The role is used to handle buttons sensitivity and visibility.
         *
         * Note that an assistant needs to end its page flow with a page of type
         * %GTK_ASSISTANT_PAGE_CONFIRM, %GTK_ASSISTANT_PAGE_SUMMARY or
         * %GTK_ASSISTANT_PAGE_PROGRESS to be correct.
         *
         * The Cancel button will only be shown if the page isn’t “committed”.
         * See gtk_assistant_commit() for details.
         */

        /**
         * Determines the page role inside a `GtkAssistant`.
         *
         * The role is used to handle buttons sensitivity and visibility.
         *
         * Note that an assistant needs to end its page flow with a page of type
         * %GTK_ASSISTANT_PAGE_CONFIRM, %GTK_ASSISTANT_PAGE_SUMMARY or
         * %GTK_ASSISTANT_PAGE_PROGRESS to be correct.
         *
         * The Cancel button will only be shown if the page isn’t “committed”.
         * See gtk_assistant_commit() for details.
         */
        export namespace AssistantPageType {
            export const $gtype: GObject.GType<AssistantPageType>;
        }

        enum AssistantPageType {
            /**
             * The page has regular contents. Both the
             *  Back and forward buttons will be shown.
             */
            CONTENT,
            /**
             * The page contains an introduction to the
             *  assistant task. Only the Forward button will be shown if there is a
             *   next page.
             */
            INTRO,
            /**
             * The page lets the user confirm or deny the
             *  changes. The Back and Apply buttons will be shown.
             */
            CONFIRM,
            /**
             * The page informs the user of the changes
             *  done. Only the Close button will be shown.
             */
            SUMMARY,
            /**
             * Used for tasks that take a long time to
             *  complete, blocks the assistant until the page is marked as complete.
             *   Only the back button will be shown.
             */
            PROGRESS,
            /**
             * Used for when other page types are not
             *  appropriate. No buttons will be shown, and the application must
             *  add its own buttons through gtk_assistant_add_action_widget().
             */
            CUSTOM,
        }
        /**
         * Baseline position in a row of widgets.
         *
         * Whenever a container has some form of natural row it may align
         * children in that row along a common typographical baseline. If
         * the amount of vertical space in the row is taller than the total
         * requested height of the baseline-aligned children then it can use a
         * `GtkBaselinePosition` to select where to put the baseline inside the
         * extra available space.
         */

        /**
         * Baseline position in a row of widgets.
         *
         * Whenever a container has some form of natural row it may align
         * children in that row along a common typographical baseline. If
         * the amount of vertical space in the row is taller than the total
         * requested height of the baseline-aligned children then it can use a
         * `GtkBaselinePosition` to select where to put the baseline inside the
         * extra available space.
         */
        export namespace BaselinePosition {
            export const $gtype: GObject.GType<BaselinePosition>;
        }

        enum BaselinePosition {
            /**
             * Align the baseline at the top
             */
            TOP,
            /**
             * Center the baseline
             */
            CENTER,
            /**
             * Align the baseline at the bottom
             */
            BOTTOM,
        }
        /**
         * Describes how the border of a UI element should be rendered.
         */

        /**
         * Describes how the border of a UI element should be rendered.
         */
        export namespace BorderStyle {
            export const $gtype: GObject.GType<BorderStyle>;
        }

        enum BorderStyle {
            /**
             * No visible border
             */
            NONE,
            /**
             * Same as %GTK_BORDER_STYLE_NONE
             */
            HIDDEN,
            /**
             * A single line segment
             */
            SOLID,
            /**
             * Looks as if the content is sunken into the canvas
             */
            INSET,
            /**
             * Looks as if the content is coming out of the canvas
             */
            OUTSET,
            /**
             * A series of round dots
             */
            DOTTED,
            /**
             * A series of square-ended dashes
             */
            DASHED,
            /**
             * Two parallel lines with some space between them
             */
            DOUBLE,
            /**
             * Looks as if it were carved in the canvas
             */
            GROOVE,
            /**
             * Looks as if it were coming out of the canvas
             */
            RIDGE,
        }
        /**
         * Error codes that identify various errors that can occur while using
         * `GtkBuilder`.
         */
        class BuilderError extends GLib.Error {
            static $gtype: GObject.GType<BuilderError>;

            // Static fields

            /**
             * A type-func attribute didn’t name
             *  a function that returns a `GType`.
             */
            static INVALID_TYPE_FUNCTION: number;
            /**
             * The input contained a tag that `GtkBuilder`
             *  can’t handle.
             */
            static UNHANDLED_TAG: number;
            /**
             * An attribute that is required by
             *  `GtkBuilder` was missing.
             */
            static MISSING_ATTRIBUTE: number;
            /**
             * `GtkBuilder` found an attribute that
             *  it doesn’t understand.
             */
            static INVALID_ATTRIBUTE: number;
            /**
             * `GtkBuilder` found a tag that
             *  it doesn’t understand.
             */
            static INVALID_TAG: number;
            /**
             * A required property value was
             *  missing.
             */
            static MISSING_PROPERTY_VALUE: number;
            /**
             * `GtkBuilder` couldn’t parse
             *  some attribute value.
             */
            static INVALID_VALUE: number;
            /**
             * The input file requires a newer version
             *  of GTK.
             */
            static VERSION_MISMATCH: number;
            /**
             * An object id occurred twice.
             */
            static DUPLICATE_ID: number;
            /**
             * A specified object type is of the same type or
             *  derived from the type of the composite class being extended with builder XML.
             */
            static OBJECT_TYPE_REFUSED: number;
            /**
             * The wrong type was specified in a composite class’s template XML
             */
            static TEMPLATE_MISMATCH: number;
            /**
             * The specified property is unknown for the object class.
             */
            static INVALID_PROPERTY: number;
            /**
             * The specified signal is unknown for the object class.
             */
            static INVALID_SIGNAL: number;
            /**
             * An object id is unknown.
             */
            static INVALID_ID: number;
            /**
             * A function could not be found. This often happens
             *   when symbols are set to be kept private. Compiling code with -rdynamic or using the
             *   `gmodule-export-2.0` pkgconfig module can fix this problem.
             */
            static INVALID_FUNCTION: number;

            // Constructors

            constructor(options: { message: string; code: number });
            _init(...args: any[]): void;

            // Static methods

            /**
             * Registers an error quark for [class`Gtk`.Builder] errors.
             */
            static quark(): GLib.Quark;
        }

        /**
         * Prebuilt sets of buttons for `GtkDialog`.
         *
         * If none of these choices are appropriate, simply use
         * %GTK_BUTTONS_NONE and call [method`Gtk`.Dialog.add_buttons].
         *
         * > Please note that %GTK_BUTTONS_OK, %GTK_BUTTONS_YES_NO
         * > and %GTK_BUTTONS_OK_CANCEL are discouraged by the
         * > [GNOME Human Interface Guidelines](https://developer.gnome.org/hig/).
         */

        /**
         * Prebuilt sets of buttons for `GtkDialog`.
         *
         * If none of these choices are appropriate, simply use
         * %GTK_BUTTONS_NONE and call [method`Gtk`.Dialog.add_buttons].
         *
         * > Please note that %GTK_BUTTONS_OK, %GTK_BUTTONS_YES_NO
         * > and %GTK_BUTTONS_OK_CANCEL are discouraged by the
         * > [GNOME Human Interface Guidelines](https://developer.gnome.org/hig/).
         */
        export namespace ButtonsType {
            export const $gtype: GObject.GType<ButtonsType>;
        }

        enum ButtonsType {
            /**
             * no buttons at all
             */
            NONE,
            /**
             * an OK button
             */
            OK,
            /**
             * a Close button
             */
            CLOSE,
            /**
             * a Cancel button
             */
            CANCEL,
            /**
             * Yes and No buttons
             */
            YES_NO,
            /**
             * OK and Cancel buttons
             */
            OK_CANCEL,
        }
        /**
         * The available modes for [property`Gtk`.CellRendererAccel:accel-mode].
         */

        /**
         * The available modes for [property`Gtk`.CellRendererAccel:accel-mode].
         */
        export namespace CellRendererAccelMode {
            export const $gtype: GObject.GType<CellRendererAccelMode>;
        }

        enum CellRendererAccelMode {
            /**
             * GTK accelerators mode
             */
            GTK,
            /**
             * Other accelerator mode
             */
            OTHER,
        }
        /**
         * Identifies how the user can interact with a particular cell.
         */

        /**
         * Identifies how the user can interact with a particular cell.
         */
        export namespace CellRendererMode {
            export const $gtype: GObject.GType<CellRendererMode>;
        }

        enum CellRendererMode {
            /**
             * The cell is just for display
             *  and cannot be interacted with.  Note that this doesn’t mean that eg. the
             *  row being drawn can’t be selected -- just that a particular element of
             *  it cannot be individually modified.
             */
            INERT,
            /**
             * The cell can be clicked.
             */
            ACTIVATABLE,
            /**
             * The cell can be edited or otherwise modified.
             */
            EDITABLE,
        }
        /**
         * Describes how a [class`Gtk`.StringSorter] turns strings into sort keys to
         * compare them.
         *
         * Note that the result of sorting will in general depend on the current locale
         * unless the mode is `GTK_COLLATION_NONE`.
         */

        /**
         * Describes how a [class`Gtk`.StringSorter] turns strings into sort keys to
         * compare them.
         *
         * Note that the result of sorting will in general depend on the current locale
         * unless the mode is `GTK_COLLATION_NONE`.
         */
        export namespace Collation {
            export const $gtype: GObject.GType<Collation>;
        }

        enum Collation {
            /**
             * Don't do any collation
             */
            NONE,
            /**
             * Use [func`GLib`.utf8_collate_key]
             */
            UNICODE,
            /**
             * Use [func`GLib`.utf8_collate_key_for_filename]
             */
            FILENAME,
        }
        /**
         * The widget attributes that can be used when creating a [class`Constraint]`.
         */

        /**
         * The widget attributes that can be used when creating a [class`Constraint]`.
         */
        export namespace ConstraintAttribute {
            export const $gtype: GObject.GType<ConstraintAttribute>;
        }

        enum ConstraintAttribute {
            /**
             * No attribute, used for constant
             *   relations
             */
            NONE,
            /**
             * The left edge of a widget, regardless of
             *   text direction
             */
            LEFT,
            /**
             * The right edge of a widget, regardless
             *   of text direction
             */
            RIGHT,
            /**
             * The top edge of a widget
             */
            TOP,
            /**
             * The bottom edge of a widget
             */
            BOTTOM,
            /**
             * The leading edge of a widget, depending
             *   on text direction; equivalent to %GTK_CONSTRAINT_ATTRIBUTE_LEFT for LTR
             *   languages, and %GTK_CONSTRAINT_ATTRIBUTE_RIGHT for RTL ones
             */
            START,
            /**
             * The trailing edge of a widget, depending
             *   on text direction; equivalent to %GTK_CONSTRAINT_ATTRIBUTE_RIGHT for LTR
             *   languages, and %GTK_CONSTRAINT_ATTRIBUTE_LEFT for RTL ones
             */
            END,
            /**
             * The width of a widget
             */
            WIDTH,
            /**
             * The height of a widget
             */
            HEIGHT,
            /**
             * The center of a widget, on the
             *   horizontal axis
             */
            CENTER_X,
            /**
             * The center of a widget, on the
             *   vertical axis
             */
            CENTER_Y,
            /**
             * The baseline of a widget
             */
            BASELINE,
        }
        /**
         * The relation between two terms of a constraint.
         */

        /**
         * The relation between two terms of a constraint.
         */
        export namespace ConstraintRelation {
            export const $gtype: GObject.GType<ConstraintRelation>;
        }

        enum ConstraintRelation {
            /**
             * Less than, or equal
             */
            LE,
            /**
             * Equal
             */
            EQ,
            /**
             * Greater than, or equal
             */
            GE,
        }
        /**
         * The strength of a constraint, expressed as a symbolic constant.
         *
         * The strength of a [class`Constraint]` can be expressed with any positive
         * integer; the values of this enumeration can be used for readability.
         */

        /**
         * The strength of a constraint, expressed as a symbolic constant.
         *
         * The strength of a [class`Constraint]` can be expressed with any positive
         * integer; the values of this enumeration can be used for readability.
         */
        export namespace ConstraintStrength {
            export const $gtype: GObject.GType<ConstraintStrength>;
        }

        enum ConstraintStrength {
            /**
             * The constraint is required towards solving the layout
             */
            REQUIRED,
            /**
             * A strong constraint
             */
            STRONG,
            /**
             * A medium constraint
             */
            MEDIUM,
            /**
             * A weak constraint
             */
            WEAK,
        }
        /**
         * Domain for VFL parsing errors.
         */
        class ConstraintVflParserError extends GLib.Error {
            static $gtype: GObject.GType<ConstraintVflParserError>;

            // Static fields

            /**
             * Invalid or unknown symbol
             */
            static SYMBOL: number;
            /**
             * Invalid or unknown attribute
             */
            static ATTRIBUTE: number;
            /**
             * Invalid or unknown view
             */
            static VIEW: number;
            /**
             * Invalid or unknown metric
             */
            static METRIC: number;
            /**
             * Invalid or unknown priority
             */
            static PRIORITY: number;
            /**
             * Invalid or unknown relation
             */
            static RELATION: number;

            // Constructors

            constructor(options: { message: string; code: number });
            _init(...args: any[]): void;

            // Static methods

            /**
             * Registers an error quark for VFL error parsing.
             */
            static quark(): GLib.Quark;
        }

        /**
         * Controls how a content should be made to fit inside an allocation.
         */

        /**
         * Controls how a content should be made to fit inside an allocation.
         */
        export namespace ContentFit {
            export const $gtype: GObject.GType<ContentFit>;
        }

        enum ContentFit {
            /**
             * Make the content fill the entire allocation,
             *   without taking its aspect ratio in consideration. The resulting
             *   content will appear as stretched if its aspect ratio is different
             *   from the allocation aspect ratio.
             */
            FILL,
            /**
             * Scale the content to fit the allocation,
             *   while taking its aspect ratio in consideration. The resulting
             *   content will appear as letterboxed if its aspect ratio is different
             *   from the allocation aspect ratio.
             */
            CONTAIN,
            /**
             * Cover the entire allocation, while taking
             *   the content aspect ratio in consideration. The resulting content
             *   will appear as clipped if its aspect ratio is different from the
             *   allocation aspect ratio.
             */
            COVER,
            /**
             * The content is scaled down to fit the
             *   allocation, if needed, otherwise its original size is used.
             */
            SCALE_DOWN,
        }
        /**
         * Specifies which corner a child widget should be placed in when packed into
         * a `GtkScrolledWindow.`
         *
         * This is effectively the opposite of where the scroll bars are placed.
         */

        /**
         * Specifies which corner a child widget should be placed in when packed into
         * a `GtkScrolledWindow.`
         *
         * This is effectively the opposite of where the scroll bars are placed.
         */
        export namespace CornerType {
            export const $gtype: GObject.GType<CornerType>;
        }

        enum CornerType {
            /**
             * Place the scrollbars on the right and bottom of the
             *   widget (default behaviour).
             */
            TOP_LEFT,
            /**
             * Place the scrollbars on the top and right of the
             *   widget.
             */
            BOTTOM_LEFT,
            /**
             * Place the scrollbars on the left and bottom of the
             *   widget.
             */
            TOP_RIGHT,
            /**
             * Place the scrollbars on the top and left of the
             *   widget.
             */
            BOTTOM_RIGHT,
        }
        /**
         * Errors that can occur while parsing CSS.
         *
         * These errors are unexpected and will cause parts of the given CSS
         * to be ignored.
         */
        class CssParserError extends GLib.Error {
            static $gtype: GObject.GType<CssParserError>;

            // Static fields

            /**
             * Unknown failure.
             */
            static FAILED: number;
            /**
             * The given text does not form valid syntax
             */
            static SYNTAX: number;
            /**
             * Failed to import a resource
             */
            static IMPORT: number;
            /**
             * The given name has not been defined
             */
            static NAME: number;
            /**
             * The given value is not correct
             */
            static UNKNOWN_VALUE: number;

            // Constructors

            constructor(options: { message: string; code: number });
            _init(...args: any[]): void;
        }

        /**
         * Warnings that can occur while parsing CSS.
         *
         * Unlike `GtkCssParserError`s, warnings do not cause the parser to
         * skip any input, but they indicate issues that should be fixed.
         */

        /**
         * Warnings that can occur while parsing CSS.
         *
         * Unlike `GtkCssParserError`s, warnings do not cause the parser to
         * skip any input, but they indicate issues that should be fixed.
         */
        export namespace CssParserWarning {
            export const $gtype: GObject.GType<CssParserWarning>;
        }

        enum CssParserWarning {
            /**
             * The given construct is
             *   deprecated and will be removed in a future version
             */
            DEPRECATED,
            /**
             * A syntax construct was used
             *   that should be avoided
             */
            SYNTAX,
            /**
             * A feature is not implemented
             */
            UNIMPLEMENTED,
        }
        /**
         * Passed to various keybinding signals for deleting text.
         */

        /**
         * Passed to various keybinding signals for deleting text.
         */
        export namespace DeleteType {
            export const $gtype: GObject.GType<DeleteType>;
        }

        enum DeleteType {
            /**
             * Delete characters.
             */
            CHARS,
            /**
             * Delete only the portion of the word to the
             *   left/right of cursor if we’re in the middle of a word.
             */
            WORD_ENDS,
            /**
             * Delete words.
             */
            WORDS,
            /**
             * Delete display-lines. Display-lines
             *   refers to the visible lines, with respect to the current line
             *   breaks. As opposed to paragraphs, which are defined by line
             *   breaks in the input.
             */
            DISPLAY_LINES,
            /**
             * Delete only the portion of the
             *   display-line to the left/right of cursor.
             */
            DISPLAY_LINE_ENDS,
            /**
             * Delete to the end of the
             *   paragraph. Like C-k in Emacs (or its reverse).
             */
            PARAGRAPH_ENDS,
            /**
             * Delete entire line. Like C-k in pico.
             */
            PARAGRAPHS,
            /**
             * Delete only whitespace. Like M-\ in Emacs.
             */
            WHITESPACE,
        }
        /**
         * Error codes in the `GTK_DIALOG_ERROR` domain that can be returned
         * by async dialog functions.
         */
        class DialogError extends GLib.Error {
            static $gtype: GObject.GType<DialogError>;

            // Static fields

            /**
             * Generic error condition for when
             *   an operation fails and no more specific code is applicable
             */
            static FAILED: number;
            /**
             * The async function call was cancelled
             *   via its `GCancellable`
             */
            static CANCELLED: number;
            /**
             * The operation was cancelled
             *   by the user (via a Cancel or Close button)
             */
            static DISMISSED: number;

            // Constructors

            constructor(options: { message: string; code: number });
            _init(...args: any[]): void;

            // Static methods

            /**
             * Registers an error quark for an operation that requires a dialog if
             * necessary.
             */
            static quark(): GLib.Quark;
        }

        /**
         * Focus movement types.
         */

        /**
         * Focus movement types.
         */
        export namespace DirectionType {
            export const $gtype: GObject.GType<DirectionType>;
        }

        enum DirectionType {
            /**
             * Move forward.
             */
            TAB_FORWARD,
            /**
             * Move backward.
             */
            TAB_BACKWARD,
            /**
             * Move up.
             */
            UP,
            /**
             * Move down.
             */
            DOWN,
            /**
             * Move left.
             */
            LEFT,
            /**
             * Move right.
             */
            RIGHT,
        }
        /**
         * The identifiers for [iface`Gtk`.Editable] properties.
         *
         * See [func`Gtk`.Editable.install_properties] for details on how to
         * implement the `GtkEditable` interface.
         */

        /**
         * The identifiers for [iface`Gtk`.Editable] properties.
         *
         * See [func`Gtk`.Editable.install_properties] for details on how to
         * implement the `GtkEditable` interface.
         */
        export namespace EditableProperties {
            export const $gtype: GObject.GType<EditableProperties>;
        }

        enum EditableProperties {
            /**
             * the property id for [property`Gtk`.Editable:text]
             */
            PROP_TEXT,
            /**
             * the property id for [property`Gtk`.Editable:cursor-position]
             */
            PROP_CURSOR_POSITION,
            /**
             * the property id for [property`Gtk`.Editable:selection-bound]
             */
            PROP_SELECTION_BOUND,
            /**
             * the property id for [property`Gtk`.Editable:editable]
             */
            PROP_EDITABLE,
            /**
             * the property id for [property`Gtk`.Editable:width-chars]
             */
            PROP_WIDTH_CHARS,
            /**
             * the property id for [property`Gtk`.Editable:max-width-chars]
             */
            PROP_MAX_WIDTH_CHARS,
            /**
             * the property id for [property`Gtk`.Editable:xalign]
             */
            PROP_XALIGN,
            /**
             * the property id for [property`Gtk`.Editable:enable-undo]
             */
            PROP_ENABLE_UNDO,
            /**
             * the number of properties
             */
            NUM_PROPERTIES,
        }
        /**
         * Specifies the side of the entry at which an icon is placed.
         */

        /**
         * Specifies the side of the entry at which an icon is placed.
         */
        export namespace EntryIconPosition {
            export const $gtype: GObject.GType<EntryIconPosition>;
        }

        enum EntryIconPosition {
            /**
             * At the beginning of the entry (depending on the text direction).
             */
            PRIMARY,
            /**
             * At the end of the entry (depending on the text direction).
             */
            SECONDARY,
        }
        /**
         * Describes the state of a [struct`Gdk`.EventSequence] in a [class`Gesture]`.
         */

        /**
         * Describes the state of a [struct`Gdk`.EventSequence] in a [class`Gesture]`.
         */
        export namespace EventSequenceState {
            export const $gtype: GObject.GType<EventSequenceState>;
        }

        enum EventSequenceState {
            /**
             * The sequence is handled, but not grabbed.
             */
            NONE,
            /**
             * The sequence is handled and grabbed.
             */
            CLAIMED,
            /**
             * The sequence is denied.
             */
            DENIED,
        }
        /**
         * Describes whether a `GtkFileChooser` is being used to open existing files
         * or to save to a possibly new file.
         */

        /**
         * Describes whether a `GtkFileChooser` is being used to open existing files
         * or to save to a possibly new file.
         */
        export namespace FileChooserAction {
            export const $gtype: GObject.GType<FileChooserAction>;
        }

        enum FileChooserAction {
            /**
             * Indicates open mode.  The file chooser
             *  will only let the user pick an existing file.
             */
            OPEN,
            /**
             * Indicates save mode.  The file chooser
             *  will let the user pick an existing file, or type in a new
             *  filename.
             */
            SAVE,
            /**
             * Indicates an Open mode for
             *  selecting folders.  The file chooser will let the user pick an
             *  existing folder.
             */
            SELECT_FOLDER,
        }
        /**
         * These identify the various errors that can occur while calling
         * `GtkFileChooser` functions.
         */
        class FileChooserError extends GLib.Error {
            static $gtype: GObject.GType<FileChooserError>;

            // Static fields

            /**
             * Indicates that a file does not exist.
             */
            static NONEXISTENT: number;
            /**
             * Indicates a malformed filename.
             */
            static BAD_FILENAME: number;
            /**
             * Indicates a duplicate path (e.g. when
             *  adding a bookmark).
             */
            static ALREADY_EXISTS: number;
            /**
             * Indicates an incomplete hostname
             *  (e.g. "http://foo" without a slash after that).
             */
            static INCOMPLETE_HOSTNAME: number;

            // Constructors

            constructor(options: { message: string; code: number });
            _init(...args: any[]): void;

            // Static methods

            /**
             * Registers an error quark for `GtkFileChooser` errors.
             */
            static quark(): GLib.Quark;
        }

        /**
         * Describes changes in a filter in more detail and allows objects
         * using the filter to optimize refiltering items.
         *
         * If you are writing an implementation and are not sure which
         * value to pass, %GTK_FILTER_CHANGE_DIFFERENT is always a correct
         * choice.
         */

        /**
         * Describes changes in a filter in more detail and allows objects
         * using the filter to optimize refiltering items.
         *
         * If you are writing an implementation and are not sure which
         * value to pass, %GTK_FILTER_CHANGE_DIFFERENT is always a correct
         * choice.
         */
        export namespace FilterChange {
            export const $gtype: GObject.GType<FilterChange>;
        }

        enum FilterChange {
            /**
             * The filter change cannot be
             *   described with any of the other enumeration values.
             */
            DIFFERENT,
            /**
             * The filter is less strict than
             *   it was before: All items that it used to return %TRUE for
             *   still return %TRUE, others now may, too.
             */
            LESS_STRICT,
            /**
             * The filter is more strict than
             *   it was before: All items that it used to return %FALSE for
             *   still return %FALSE, others now may, too.
             */
            MORE_STRICT,
        }
        /**
         * Describes the known strictness of a filter.
         *
         * Note that for filters where the strictness is not known,
         * %GTK_FILTER_MATCH_SOME is always an acceptable value,
         * even if a filter does match all or no items.
         */

        /**
         * Describes the known strictness of a filter.
         *
         * Note that for filters where the strictness is not known,
         * %GTK_FILTER_MATCH_SOME is always an acceptable value,
         * even if a filter does match all or no items.
         */
        export namespace FilterMatch {
            export const $gtype: GObject.GType<FilterMatch>;
        }

        enum FilterMatch {
            /**
             * The filter matches some items,
             *   gtk_filter_match() may return %TRUE or %FALSE
             */
            SOME,
            /**
             * The filter does not match any item,
             *   gtk_filter_match() will always return %FALSE.
             */
            NONE,
            /**
             * The filter matches all items,
             *   gtk_filter_match() will alays return %TRUE.
             */
            ALL,
        }
        /**
         * The level of granularity for the font selection.
         *
         * Depending on this value, the `PangoFontDescription` that
         * is returned by [method`Gtk`.FontDialogButton.get_font_desc]
         * will have more or less fields set.
         */

        /**
         * The level of granularity for the font selection.
         *
         * Depending on this value, the `PangoFontDescription` that
         * is returned by [method`Gtk`.FontDialogButton.get_font_desc]
         * will have more or less fields set.
         */
        export namespace FontLevel {
            export const $gtype: GObject.GType<FontLevel>;
        }

        enum FontLevel {
            /**
             * Select a font family
             */
            FAMILY,
            /**
             * Select a font face (i.e. a family and a style)
             */
            FACE,
            /**
             * Select a font (i.e. a face with a size, and possibly font variations)
             */
            FONT,
            /**
             * Select a font and font features
             */
            FEATURES,
        }
        /**
         * Values for the [property`Gtk`.Settings:gtk-font-rendering] setting
         * that influence how GTK renders fonts.
         */

        /**
         * Values for the [property`Gtk`.Settings:gtk-font-rendering] setting
         * that influence how GTK renders fonts.
         */
        export namespace FontRendering {
            export const $gtype: GObject.GType<FontRendering>;
        }

        enum FontRendering {
            /**
             * Set up font rendering automatically,
             *   taking factors like screen resolution and scale into account
             */
            AUTOMATIC,
            /**
             * Follow low-level font-related settings
             *   when configuring font rendering
             */
            MANUAL,
        }
        /**
         * Represents the state of graphics offloading.
         */

        /**
         * Represents the state of graphics offloading.
         */
        export namespace GraphicsOffloadEnabled {
            export const $gtype: GObject.GType<GraphicsOffloadEnabled>;
        }

        enum GraphicsOffloadEnabled {
            /**
             * Graphics offloading is enabled.
             */
            ENABLED,
            /**
             * Graphics offloading is disabled.
             */
            DISABLED,
        }
        /**
         * Built-in icon sizes.
         *
         * Icon sizes default to being inherited. Where they cannot be
         * inherited, text size is the default.
         *
         * All widgets which use `GtkIconSize` set the normal-icons or
         * large-icons style classes correspondingly, and let themes
         * determine the actual size to be used with the
         * `-gtk-icon-size` CSS property.
         */

        /**
         * Built-in icon sizes.
         *
         * Icon sizes default to being inherited. Where they cannot be
         * inherited, text size is the default.
         *
         * All widgets which use `GtkIconSize` set the normal-icons or
         * large-icons style classes correspondingly, and let themes
         * determine the actual size to be used with the
         * `-gtk-icon-size` CSS property.
         */
        export namespace IconSize {
            export const $gtype: GObject.GType<IconSize>;
        }

        enum IconSize {
            /**
             * Keep the size of the parent element
             */
            INHERIT,
            /**
             * Size similar to text size
             */
            NORMAL,
            /**
             * Large size, for example in an icon view
             */
            LARGE,
        }
        /**
         * Error codes for `GtkIconTheme` operations.
         */
        class IconThemeError extends GLib.Error {
            static $gtype: GObject.GType<IconThemeError>;

            // Static fields

            /**
             * The icon specified does not exist in the theme
             */
            static NOT_FOUND: number;
            /**
             * An unspecified error occurred.
             */
            static FAILED: number;

            // Constructors

            constructor(options: { message: string; code: number });
            _init(...args: any[]): void;

            // Static methods

            /**
             * Registers an error quark for [class`Gtk`.IconTheme] errors.
             */
            static quark(): GLib.Quark;
        }

        /**
         * An enum for determining where a dropped item goes.
         */

        /**
         * An enum for determining where a dropped item goes.
         */
        export namespace IconViewDropPosition {
            export const $gtype: GObject.GType<IconViewDropPosition>;
        }

        enum IconViewDropPosition {
            /**
             * no drop possible
             */
            NO_DROP,
            /**
             * dropped item replaces the item
             */
            DROP_INTO,
            /**
             * dropped item is inserted to the left
             */
            DROP_LEFT,
            /**
             * dropped item is inserted to the right
             */
            DROP_RIGHT,
            /**
             * dropped item is inserted above
             */
            DROP_ABOVE,
            /**
             * dropped item is inserted below
             */
            DROP_BELOW,
        }
        /**
         * Describes the image data representation used by a [class`Gtk`.Image].
         *
         * If you want to get the image from the widget, you can only get the
         * currently-stored representation; for instance, if the gtk_image_get_storage_type()
         * returns %GTK_IMAGE_PAINTABLE, then you can call gtk_image_get_paintable().
         *
         * For empty images, you can request any storage type (call any of the "get"
         * functions), but they will all return %NULL values.
         */

        /**
         * Describes the image data representation used by a [class`Gtk`.Image].
         *
         * If you want to get the image from the widget, you can only get the
         * currently-stored representation; for instance, if the gtk_image_get_storage_type()
         * returns %GTK_IMAGE_PAINTABLE, then you can call gtk_image_get_paintable().
         *
         * For empty images, you can request any storage type (call any of the "get"
         * functions), but they will all return %NULL values.
         */
        export namespace ImageType {
            export const $gtype: GObject.GType<ImageType>;
        }

        enum ImageType {
            /**
             * there is no image displayed by the widget
             */
            EMPTY,
            /**
             * the widget contains a named icon
             */
            ICON_NAME,
            /**
             * the widget contains a `GIcon`
             */
            GICON,
            /**
             * the widget contains a `GdkPaintable`
             */
            PAINTABLE,
        }
        /**
         * Describes primary purpose of the input widget.
         *
         * This information is useful for on-screen keyboards and similar input
         * methods to decide which keys should be presented to the user.
         *
         * Note that the purpose is not meant to impose a totally strict rule
         * about allowed characters, and does not replace input validation.
         * It is fine for an on-screen keyboard to let the user override the
         * character set restriction that is expressed by the purpose. The
         * application is expected to validate the entry contents, even if
         * it specified a purpose.
         *
         * The difference between %GTK_INPUT_PURPOSE_DIGITS and
         * %GTK_INPUT_PURPOSE_NUMBER is that the former accepts only digits
         * while the latter also some punctuation (like commas or points, plus,
         * minus) and “e” or “E” as in 3.14E+000.
         *
         * This enumeration may be extended in the future; input methods should
         * interpret unknown values as “free form”.
         */

        /**
         * Describes primary purpose of the input widget.
         *
         * This information is useful for on-screen keyboards and similar input
         * methods to decide which keys should be presented to the user.
         *
         * Note that the purpose is not meant to impose a totally strict rule
         * about allowed characters, and does not replace input validation.
         * It is fine for an on-screen keyboard to let the user override the
         * character set restriction that is expressed by the purpose. The
         * application is expected to validate the entry contents, even if
         * it specified a purpose.
         *
         * The difference between %GTK_INPUT_PURPOSE_DIGITS and
         * %GTK_INPUT_PURPOSE_NUMBER is that the former accepts only digits
         * while the latter also some punctuation (like commas or points, plus,
         * minus) and “e” or “E” as in 3.14E+000.
         *
         * This enumeration may be extended in the future; input methods should
         * interpret unknown values as “free form”.
         */
        export namespace InputPurpose {
            export const $gtype: GObject.GType<InputPurpose>;
        }

        enum InputPurpose {
            /**
             * Allow any character
             */
            FREE_FORM,
            /**
             * Allow only alphabetic characters
             */
            ALPHA,
            /**
             * Allow only digits
             */
            DIGITS,
            /**
             * Edited field expects numbers
             */
            NUMBER,
            /**
             * Edited field expects phone number
             */
            PHONE,
            /**
             * Edited field expects URL
             */
            URL,
            /**
             * Edited field expects email address
             */
            EMAIL,
            /**
             * Edited field expects the name of a person
             */
            NAME,
            /**
             * Like %GTK_INPUT_PURPOSE_FREE_FORM, but characters are hidden
             */
            PASSWORD,
            /**
             * Like %GTK_INPUT_PURPOSE_DIGITS, but characters are hidden
             */
            PIN,
            /**
             * Allow any character, in addition to control codes
             */
            TERMINAL,
        }
        /**
         * The different methods to handle text in #GtkInscription when it doesn't
         * fit the available space.
         */

        /**
         * The different methods to handle text in #GtkInscription when it doesn't
         * fit the available space.
         */
        export namespace InscriptionOverflow {
            export const $gtype: GObject.GType<InscriptionOverflow>;
        }

        enum InscriptionOverflow {
            /**
             * Clip the remaining text
             */
            CLIP,
            /**
             * Omit characters at the start of the text
             */
            ELLIPSIZE_START,
            /**
             * Omit characters at the middle of the text
             */
            ELLIPSIZE_MIDDLE,
            /**
             * Omit characters at the end of the text
             */
            ELLIPSIZE_END,
        }
        /**
         * Used for justifying the text inside a [class`Label]` widget.
         */

        /**
         * Used for justifying the text inside a [class`Label]` widget.
         */
        export namespace Justification {
            export const $gtype: GObject.GType<Justification>;
        }

        enum Justification {
            /**
             * The text is placed at the left edge of the label.
             */
            LEFT,
            /**
             * The text is placed at the right edge of the label.
             */
            RIGHT,
            /**
             * The text is placed in the center of the label.
             */
            CENTER,
            /**
             * The text is placed is distributed across the label.
             */
            FILL,
        }
        /**
         * Describes how [class`LevelBar]` contents should be rendered.
         *
         * Note that this enumeration could be extended with additional modes
         * in the future.
         */

        /**
         * Describes how [class`LevelBar]` contents should be rendered.
         *
         * Note that this enumeration could be extended with additional modes
         * in the future.
         */
        export namespace LevelBarMode {
            export const $gtype: GObject.GType<LevelBarMode>;
        }

        enum LevelBarMode {
            /**
             * the bar has a continuous mode
             */
            CONTINUOUS,
            /**
             * the bar has a discrete mode
             */
            DISCRETE,
        }
        /**
         * The type of license for an application.
         *
         * This enumeration can be expanded at later date.
         */

        /**
         * The type of license for an application.
         *
         * This enumeration can be expanded at later date.
         */
        export namespace License {
            export const $gtype: GObject.GType<License>;
        }

        enum License {
            /**
             * No license specified
             */
            UNKNOWN,
            /**
             * A license text is going to be specified by the
             *   developer
             */
            CUSTOM,
            /**
             * The GNU General Public License, version 2.0 or later
             */
            GPL_2_0,
            /**
             * The GNU General Public License, version 3.0 or later
             */
            GPL_3_0,
            /**
             * The GNU Lesser General Public License, version 2.1 or later
             */
            LGPL_2_1,
            /**
             * The GNU Lesser General Public License, version 3.0 or later
             */
            LGPL_3_0,
            /**
             * The BSD standard license
             */
            BSD,
            /**
             * The MIT/X11 standard license
             */
            MIT_X11,
            /**
             * The Artistic License, version 2.0
             */
            ARTISTIC,
            /**
             * The GNU General Public License, version 2.0 only
             */
            GPL_2_0_ONLY,
            /**
             * The GNU General Public License, version 3.0 only
             */
            GPL_3_0_ONLY,
            /**
             * The GNU Lesser General Public License, version 2.1 only
             */
            LGPL_2_1_ONLY,
            /**
             * The GNU Lesser General Public License, version 3.0 only
             */
            LGPL_3_0_ONLY,
            /**
             * The GNU Affero General Public License, version 3.0 or later
             */
            AGPL_3_0,
            /**
             * The GNU Affero General Public License, version 3.0 only
             */
            AGPL_3_0_ONLY,
            /**
             * The 3-clause BSD licence
             */
            BSD_3,
            /**
             * The Apache License, version 2.0
             */
            APACHE_2_0,
            /**
             * The Mozilla Public License, version 2.0
             */
            MPL_2_0,
            /**
             * Zero-Clause BSD license
             */
            '0BSD',
        }
        /**
         * Used to configure the focus behavior in the `GTK_DIR_TAB_FORWARD`
         * and `GTK_DIR_TAB_BACKWARD` direction, like the <kbd>Tab</kbd> key
         * in a [class`Gtk`.ListView].
         */

        /**
         * Used to configure the focus behavior in the `GTK_DIR_TAB_FORWARD`
         * and `GTK_DIR_TAB_BACKWARD` direction, like the <kbd>Tab</kbd> key
         * in a [class`Gtk`.ListView].
         */
        export namespace ListTabBehavior {
            export const $gtype: GObject.GType<ListTabBehavior>;
        }

        enum ListTabBehavior {
            /**
             * Cycle through all focusable items of the list
             */
            ALL,
            /**
             * Cycle through a single list element, then move
             *   focus out of the list. Moving focus between items needs to be
             *   done with the arrow keys.
             */
            ITEM,
            /**
             * Cycle only through a single cell, then
             *   move focus out of the list. Moving focus between cells needs to
             *   be done with the arrow keys. This is only relevant for
             *   cell-based widgets like #GtkColumnView, otherwise it behaves
             *   like `GTK_LIST_TAB_ITEM`.
             */
            CELL,
        }
        /**
         * The type of message being displayed in a [class`MessageDialog]`.
         */

        /**
         * The type of message being displayed in a [class`MessageDialog]`.
         */
        export namespace MessageType {
            export const $gtype: GObject.GType<MessageType>;
        }

        enum MessageType {
            /**
             * Informational message
             */
            INFO,
            /**
             * Non-fatal warning message
             */
            WARNING,
            /**
             * Question requiring a choice
             */
            QUESTION,
            /**
             * Fatal error message
             */
            ERROR,
            /**
             * None of the above
             */
            OTHER,
        }
        /**
         * Passed as argument to various keybinding signals for moving the
         * cursor position.
         */

        /**
         * Passed as argument to various keybinding signals for moving the
         * cursor position.
         */
        export namespace MovementStep {
            export const $gtype: GObject.GType<MovementStep>;
        }

        enum MovementStep {
            /**
             * Move forward or back by graphemes
             */
            LOGICAL_POSITIONS,
            /**
             * Move left or right by graphemes
             */
            VISUAL_POSITIONS,
            /**
             * Move forward or back by words
             */
            WORDS,
            /**
             * Move up or down lines (wrapped lines)
             */
            DISPLAY_LINES,
            /**
             * Move to either end of a line
             */
            DISPLAY_LINE_ENDS,
            /**
             * Move up or down paragraphs (newline-ended lines)
             */
            PARAGRAPHS,
            /**
             * Move to either end of a paragraph
             */
            PARAGRAPH_ENDS,
            /**
             * Move by pages
             */
            PAGES,
            /**
             * Move to ends of the buffer
             */
            BUFFER_ENDS,
            /**
             * Move horizontally by pages
             */
            HORIZONTAL_PAGES,
        }
        /**
         * Options for selecting a different wrap mode for natural size
         * requests.
         *
         * See for example the [property`Gtk`.Label:natural-wrap-mode] property.
         */

        /**
         * Options for selecting a different wrap mode for natural size
         * requests.
         *
         * See for example the [property`Gtk`.Label:natural-wrap-mode] property.
         */
        export namespace NaturalWrapMode {
            export const $gtype: GObject.GType<NaturalWrapMode>;
        }

        enum NaturalWrapMode {
            /**
             * Inherit the minimum size request.
             *   In particular, this should be used with %PANGO_WRAP_CHAR.
             */
            INHERIT,
            /**
             * Try not to wrap the text. This mode is the
             *   closest to GTK3's behavior but can lead to a wide label leaving
             *   lots of empty space below the text.
             */
            NONE,
            /**
             * Attempt to wrap at word boundaries. This
             *   is useful in particular when using %PANGO_WRAP_WORD_CHAR as the
             *   wrap mode.
             */
            WORD,
        }
        /**
         * The parameter used in the action signals of `GtkNotebook`.
         */

        /**
         * The parameter used in the action signals of `GtkNotebook`.
         */
        export namespace NotebookTab {
            export const $gtype: GObject.GType<NotebookTab>;
        }

        enum NotebookTab {
            /**
             * the first tab in the notebook
             */
            FIRST,
            /**
             * the last tab in the notebook
             */
            LAST,
        }
        /**
         * Used to determine the layout of pages on a sheet when printing
         * multiple pages per sheet.
         */

        /**
         * Used to determine the layout of pages on a sheet when printing
         * multiple pages per sheet.
         */
        export namespace NumberUpLayout {
            export const $gtype: GObject.GType<NumberUpLayout>;
        }

        enum NumberUpLayout {
            /**
             * ![](layout-lrtb.png)
             */
            LRTB,
            /**
             * ![](layout-lrbt.png)
             */
            LRBT,
            /**
             * ![](layout-rltb.png)
             */
            RLTB,
            /**
             * ![](layout-rlbt.png)
             */
            RLBT,
            /**
             * ![](layout-tblr.png)
             */
            TBLR,
            /**
             * ![](layout-tbrl.png)
             */
            TBRL,
            /**
             * ![](layout-btlr.png)
             */
            BTLR,
            /**
             * ![](layout-btrl.png)
             */
            BTRL,
        }
        /**
         * Describes the way two values can be compared.
         *
         * These values can be used with a [callback`GLib`.CompareFunc]. However,
         * a `GCompareFunc` is allowed to return any integer values.
         * For converting such a value to a `GtkOrdering` value, use
         * [func`Gtk`.Ordering.from_cmpfunc].
         */

        /**
         * Describes the way two values can be compared.
         *
         * These values can be used with a [callback`GLib`.CompareFunc]. However,
         * a `GCompareFunc` is allowed to return any integer values.
         * For converting such a value to a `GtkOrdering` value, use
         * [func`Gtk`.Ordering.from_cmpfunc].
         */
        export namespace Ordering {
            export const $gtype: GObject.GType<Ordering>;
        }

        enum Ordering {
            /**
             * the first value is smaller than the second
             */
            SMALLER,
            /**
             * the two values are equal
             */
            EQUAL,
            /**
             * the first value is larger than the second
             */
            LARGER,
        }
        /**
         * Represents the orientation of widgets and other objects.
         *
         * Typical examples are [class`Box]` or [class`GesturePan]`.
         */

        /**
         * Represents the orientation of widgets and other objects.
         *
         * Typical examples are [class`Box]` or [class`GesturePan]`.
         */
        export namespace Orientation {
            export const $gtype: GObject.GType<Orientation>;
        }

        enum Orientation {
            /**
             * The element is in horizontal orientation.
             */
            HORIZONTAL,
            /**
             * The element is in vertical orientation.
             */
            VERTICAL,
        }
        /**
         * Defines how content overflowing a given area should be handled.
         *
         * This is used in [method`Gtk`.Widget.set_overflow]. The
         * [property`Gtk`.Widget:overflow] property is modeled after the
         * CSS overflow property, but implements it only partially.
         */

        /**
         * Defines how content overflowing a given area should be handled.
         *
         * This is used in [method`Gtk`.Widget.set_overflow]. The
         * [property`Gtk`.Widget:overflow] property is modeled after the
         * CSS overflow property, but implements it only partially.
         */
        export namespace Overflow {
            export const $gtype: GObject.GType<Overflow>;
        }

        enum Overflow {
            /**
             * No change is applied. Content is drawn at the specified
             *   position.
             */
            VISIBLE,
            /**
             * Content is clipped to the bounds of the area. Content
             *   outside the area is not drawn and cannot be interacted with.
             */
            HIDDEN,
        }
        /**
         * Represents the packing location of a children in its parent.
         *
         * See [class`WindowControls]` for example.
         */

        /**
         * Represents the packing location of a children in its parent.
         *
         * See [class`WindowControls]` for example.
         */
        export namespace PackType {
            export const $gtype: GObject.GType<PackType>;
        }

        enum PackType {
            /**
             * The child is packed into the start of the widget
             */
            START,
            /**
             * The child is packed into the end of the widget
             */
            END,
        }
        /**
         * The type of a pad action.
         */

        /**
         * The type of a pad action.
         */
        export namespace PadActionType {
            export const $gtype: GObject.GType<PadActionType>;
        }

        enum PadActionType {
            /**
             * Action is triggered by a pad button
             */
            BUTTON,
            /**
             * Action is triggered by a pad ring
             */
            RING,
            /**
             * Action is triggered by a pad strip
             */
            STRIP,
        }
        /**
         * See also gtk_print_settings_set_orientation().
         */

        /**
         * See also gtk_print_settings_set_orientation().
         */
        export namespace PageOrientation {
            export const $gtype: GObject.GType<PageOrientation>;
        }

        enum PageOrientation {
            /**
             * Portrait mode.
             */
            PORTRAIT,
            /**
             * Landscape mode.
             */
            LANDSCAPE,
            /**
             * Reverse portrait mode.
             */
            REVERSE_PORTRAIT,
            /**
             * Reverse landscape mode.
             */
            REVERSE_LANDSCAPE,
        }
        /**
         * See also gtk_print_job_set_page_set().
         */

        /**
         * See also gtk_print_job_set_page_set().
         */
        export namespace PageSet {
            export const $gtype: GObject.GType<PageSet>;
        }

        enum PageSet {
            /**
             * All pages.
             */
            ALL,
            /**
             * Even pages.
             */
            EVEN,
            /**
             * Odd pages.
             */
            ODD,
        }
        /**
         * Describes the panning direction of a [class`GesturePan]`.
         */

        /**
         * Describes the panning direction of a [class`GesturePan]`.
         */
        export namespace PanDirection {
            export const $gtype: GObject.GType<PanDirection>;
        }

        enum PanDirection {
            /**
             * panned towards the left
             */
            LEFT,
            /**
             * panned towards the right
             */
            RIGHT,
            /**
             * panned upwards
             */
            UP,
            /**
             * panned downwards
             */
            DOWN,
        }
        /**
         * Determines how the size should be computed to achieve the one of the
         * visibility mode for the scrollbars.
         */

        /**
         * Determines how the size should be computed to achieve the one of the
         * visibility mode for the scrollbars.
         */
        export namespace PolicyType {
            export const $gtype: GObject.GType<PolicyType>;
        }

        enum PolicyType {
            /**
             * The scrollbar is always visible. The view size is
             *   independent of the content.
             */
            ALWAYS,
            /**
             * The scrollbar will appear and disappear as necessary.
             *   For example, when all of a `GtkTreeView` can not be seen.
             */
            AUTOMATIC,
            /**
             * The scrollbar should never appear. In this mode the
             *   content determines the size.
             */
            NEVER,
            /**
             * Don't show a scrollbar, but don't force the
             *   size to follow the content. This can be used e.g. to make multiple
             *   scrolled windows share a scrollbar.
             */
            EXTERNAL,
        }
        /**
         * Describes which edge of a widget a certain feature is positioned at.
         *
         * For examples, see the tabs of a [class`Notebook]`, or the label
         * of a [class`Scale]`.
         */

        /**
         * Describes which edge of a widget a certain feature is positioned at.
         *
         * For examples, see the tabs of a [class`Notebook]`, or the label
         * of a [class`Scale]`.
         */
        export namespace PositionType {
            export const $gtype: GObject.GType<PositionType>;
        }

        enum PositionType {
            /**
             * The feature is at the left edge.
             */
            LEFT,
            /**
             * The feature is at the right edge.
             */
            RIGHT,
            /**
             * The feature is at the top edge.
             */
            TOP,
            /**
             * The feature is at the bottom edge.
             */
            BOTTOM,
        }
        /**
         * See also gtk_print_settings_set_duplex().
         */

        /**
         * See also gtk_print_settings_set_duplex().
         */
        export namespace PrintDuplex {
            export const $gtype: GObject.GType<PrintDuplex>;
        }

        enum PrintDuplex {
            /**
             * No duplex.
             */
            SIMPLEX,
            /**
             * Horizontal duplex.
             */
            HORIZONTAL,
            /**
             * Vertical duplex.
             */
            VERTICAL,
        }
        /**
         * Error codes that identify various errors that can occur while
         * using the GTK printing support.
         */
        class PrintError extends GLib.Error {
            static $gtype: GObject.GType<PrintError>;

            // Static fields

            /**
             * An unspecified error occurred.
             */
            static GENERAL: number;
            /**
             * An internal error occurred.
             */
            static INTERNAL_ERROR: number;
            /**
             * A memory allocation failed.
             */
            static NOMEM: number;
            /**
             * An error occurred while loading a page setup
             *   or paper size from a key file.
             */
            static INVALID_FILE: number;

            // Constructors

            constructor(options: { message: string; code: number });
            _init(...args: any[]): void;

            // Static methods

            /**
             * Registers an error quark for `GtkPrintOperation` if necessary.
             */
            static quark(): GLib.Quark;
        }

        /**
         * Determines what action the print operation should perform.
         *
         * A parameter of this typs is passed to [method`Gtk`.PrintOperation.run].
         */

        /**
         * Determines what action the print operation should perform.
         *
         * A parameter of this typs is passed to [method`Gtk`.PrintOperation.run].
         */
        export namespace PrintOperationAction {
            export const $gtype: GObject.GType<PrintOperationAction>;
        }

        enum PrintOperationAction {
            /**
             * Show the print dialog.
             */
            PRINT_DIALOG,
            /**
             * Start to print without showing
             *   the print dialog, based on the current print settings.
             */
            PRINT,
            /**
             * Show the print preview.
             */
            PREVIEW,
            /**
             * Export to a file. This requires
             *   the export-filename property to be set.
             */
            EXPORT,
        }
        /**
         * The result of a print operation.
         *
         * A value of this type is returned by [method`Gtk`.PrintOperation.run].
         */

        /**
         * The result of a print operation.
         *
         * A value of this type is returned by [method`Gtk`.PrintOperation.run].
         */
        export namespace PrintOperationResult {
            export const $gtype: GObject.GType<PrintOperationResult>;
        }

        enum PrintOperationResult {
            /**
             * An error has occurred.
             */
            ERROR,
            /**
             * The print settings should be stored.
             */
            APPLY,
            /**
             * The print operation has been canceled,
             *   the print settings should not be stored.
             */
            CANCEL,
            /**
             * The print operation is not complete
             *   yet. This value will only be returned when running asynchronously.
             */
            IN_PROGRESS,
        }
        /**
         * See also gtk_print_job_set_pages()
         */

        /**
         * See also gtk_print_job_set_pages()
         */
        export namespace PrintPages {
            export const $gtype: GObject.GType<PrintPages>;
        }

        enum PrintPages {
            /**
             * All pages.
             */
            ALL,
            /**
             * Current page.
             */
            CURRENT,
            /**
             * Range of pages.
             */
            RANGES,
            /**
             * Selected pages.
             */
            SELECTION,
        }
        /**
         * See also gtk_print_settings_set_quality().
         */

        /**
         * See also gtk_print_settings_set_quality().
         */
        export namespace PrintQuality {
            export const $gtype: GObject.GType<PrintQuality>;
        }

        enum PrintQuality {
            /**
             * Low quality.
             */
            LOW,
            /**
             * Normal quality.
             */
            NORMAL,
            /**
             * High quality.
             */
            HIGH,
            /**
             * Draft quality.
             */
            DRAFT,
        }
        /**
         * The status gives a rough indication of the completion of a running
         * print operation.
         */

        /**
         * The status gives a rough indication of the completion of a running
         * print operation.
         */
        export namespace PrintStatus {
            export const $gtype: GObject.GType<PrintStatus>;
        }

        enum PrintStatus {
            /**
             * The printing has not started yet; this
             *   status is set initially, and while the print dialog is shown.
             */
            INITIAL,
            /**
             * This status is set while the begin-print
             *   signal is emitted and during pagination.
             */
            PREPARING,
            /**
             * This status is set while the
             *   pages are being rendered.
             */
            GENERATING_DATA,
            /**
             * The print job is being sent off to the
             *   printer.
             */
            SENDING_DATA,
            /**
             * The print job has been sent to the printer,
             *   but is not printed for some reason, e.g. the printer may be stopped.
             */
            PENDING,
            /**
             * Some problem has occurred during
             *   printing, e.g. a paper jam.
             */
            PENDING_ISSUE,
            /**
             * The printer is processing the print job.
             */
            PRINTING,
            /**
             * The printing has been completed successfully.
             */
            FINISHED,
            /**
             * The printing has been aborted.
             */
            FINISHED_ABORTED,
        }
        /**
         * Describes limits of a [class`EventController]` for handling events
         * targeting other widgets.
         */

        /**
         * Describes limits of a [class`EventController]` for handling events
         * targeting other widgets.
         */
        export namespace PropagationLimit {
            export const $gtype: GObject.GType<PropagationLimit>;
        }

        enum PropagationLimit {
            /**
             * Events are handled regardless of what their
             *   target is.
             */
            NONE,
            /**
             * Events are only handled if their target
             *   is in the same [iface`Native]` as the event controllers widget. Note
             *   that some event types have two targets (origin and destination).
             */
            SAME_NATIVE,
        }
        /**
         * Describes the stage at which events are fed into a [class`EventController]`.
         */

        /**
         * Describes the stage at which events are fed into a [class`EventController]`.
         */
        export namespace PropagationPhase {
            export const $gtype: GObject.GType<PropagationPhase>;
        }

        enum PropagationPhase {
            /**
             * Events are not delivered.
             */
            NONE,
            /**
             * Events are delivered in the capture phase. The
             *   capture phase happens before the bubble phase, runs from the toplevel down
             *   to the event widget. This option should only be used on containers that
             *   might possibly handle events before their children do.
             */
            CAPTURE,
            /**
             * Events are delivered in the bubble phase. The bubble
             *   phase happens after the capture phase, and before the default handlers
             *   are run. This phase runs from the event widget, up to the toplevel.
             */
            BUBBLE,
            /**
             * Events are delivered in the default widget event handlers,
             *   note that widget implementations must chain up on button, motion, touch and
             *   grab broken handlers for controllers in this phase to be run.
             */
            TARGET,
        }
        /**
         * Error codes for `GtkRecentManager` operations
         */
        class RecentManagerError extends GLib.Error {
            static $gtype: GObject.GType<RecentManagerError>;

            // Static fields

            /**
             * the URI specified does not exists in
             *   the recently used resources list.
             */
            static NOT_FOUND: number;
            /**
             * the URI specified is not valid.
             */
            static INVALID_URI: number;
            /**
             * the supplied string is not
             *   UTF-8 encoded.
             */
            static INVALID_ENCODING: number;
            /**
             * no application has registered
             *   the specified item.
             */
            static NOT_REGISTERED: number;
            /**
             * failure while reading the recently used
             *   resources file.
             */
            static READ: number;
            /**
             * failure while writing the recently used
             *   resources file.
             */
            static WRITE: number;
            /**
             * unspecified error.
             */
            static UNKNOWN: number;

            // Constructors

            constructor(options: { message: string; code: number });
            _init(...args: any[]): void;

            // Static methods

            /**
             * Registers an error quark for [class`RecentManager]` errors.
             */
            static quark(): GLib.Quark;
        }

        /**
         * Predefined values for use as response ids in gtk_dialog_add_button().
         *
         * All predefined values are negative; GTK leaves values of 0 or greater for
         * application-defined response ids.
         */

        /**
         * Predefined values for use as response ids in gtk_dialog_add_button().
         *
         * All predefined values are negative; GTK leaves values of 0 or greater for
         * application-defined response ids.
         */
        export namespace ResponseType {
            export const $gtype: GObject.GType<ResponseType>;
        }

        enum ResponseType {
            /**
             * Returned if an action widget has no response id,
             *   or if the dialog gets programmatically hidden or destroyed
             */
            NONE,
            /**
             * Generic response id, not used by GTK dialogs
             */
            REJECT,
            /**
             * Generic response id, not used by GTK dialogs
             */
            ACCEPT,
            /**
             * Returned if the dialog is deleted
             */
            DELETE_EVENT,
            /**
             * Returned by OK buttons in GTK dialogs
             */
            OK,
            /**
             * Returned by Cancel buttons in GTK dialogs
             */
            CANCEL,
            /**
             * Returned by Close buttons in GTK dialogs
             */
            CLOSE,
            /**
             * Returned by Yes buttons in GTK dialogs
             */
            YES,
            /**
             * Returned by No buttons in GTK dialogs
             */
            NO,
            /**
             * Returned by Apply buttons in GTK dialogs
             */
            APPLY,
            /**
             * Returned by Help buttons in GTK dialogs
             */
            HELP,
        }
        /**
         * These enumeration values describe the possible transitions
         * when the child of a `GtkRevealer` widget is shown or hidden.
         */

        /**
         * These enumeration values describe the possible transitions
         * when the child of a `GtkRevealer` widget is shown or hidden.
         */
        export namespace RevealerTransitionType {
            export const $gtype: GObject.GType<RevealerTransitionType>;
        }

        enum RevealerTransitionType {
            /**
             * No transition
             */
            NONE,
            /**
             * Fade in
             */
            CROSSFADE,
            /**
             * Slide in from the left
             */
            SLIDE_RIGHT,
            /**
             * Slide in from the right
             */
            SLIDE_LEFT,
            /**
             * Slide in from the bottom
             */
            SLIDE_UP,
            /**
             * Slide in from the top
             */
            SLIDE_DOWN,
            /**
             * Floop in from the left
             */
            SWING_RIGHT,
            /**
             * Floop in from the right
             */
            SWING_LEFT,
            /**
             * Floop in from the bottom
             */
            SWING_UP,
            /**
             * Floop in from the top
             */
            SWING_DOWN,
        }
        /**
         * Passed as argument to various keybinding signals.
         */

        /**
         * Passed as argument to various keybinding signals.
         */
        export namespace ScrollStep {
            export const $gtype: GObject.GType<ScrollStep>;
        }

        enum ScrollStep {
            /**
             * Scroll in steps.
             */
            STEPS,
            /**
             * Scroll by pages.
             */
            PAGES,
            /**
             * Scroll to ends.
             */
            ENDS,
            /**
             * Scroll in horizontal steps.
             */
            HORIZONTAL_STEPS,
            /**
             * Scroll by horizontal pages.
             */
            HORIZONTAL_PAGES,
            /**
             * Scroll to the horizontal ends.
             */
            HORIZONTAL_ENDS,
        }
        /**
         * Scrolling types.
         */

        /**
         * Scrolling types.
         */
        export namespace ScrollType {
            export const $gtype: GObject.GType<ScrollType>;
        }

        enum ScrollType {
            /**
             * No scrolling.
             */
            NONE,
            /**
             * Jump to new location.
             */
            JUMP,
            /**
             * Step backward.
             */
            STEP_BACKWARD,
            /**
             * Step forward.
             */
            STEP_FORWARD,
            /**
             * Page backward.
             */
            PAGE_BACKWARD,
            /**
             * Page forward.
             */
            PAGE_FORWARD,
            /**
             * Step up.
             */
            STEP_UP,
            /**
             * Step down.
             */
            STEP_DOWN,
            /**
             * Page up.
             */
            PAGE_UP,
            /**
             * Page down.
             */
            PAGE_DOWN,
            /**
             * Step to the left.
             */
            STEP_LEFT,
            /**
             * Step to the right.
             */
            STEP_RIGHT,
            /**
             * Page to the left.
             */
            PAGE_LEFT,
            /**
             * Page to the right.
             */
            PAGE_RIGHT,
            /**
             * Scroll to start.
             */
            START,
            /**
             * Scroll to end.
             */
            END,
        }
        /**
         * Defines the policy to be used in a scrollable widget when updating
         * the scrolled window adjustments in a given orientation.
         */

        /**
         * Defines the policy to be used in a scrollable widget when updating
         * the scrolled window adjustments in a given orientation.
         */
        export namespace ScrollablePolicy {
            export const $gtype: GObject.GType<ScrollablePolicy>;
        }

        enum ScrollablePolicy {
            /**
             * Scrollable adjustments are based on the minimum size
             */
            MINIMUM,
            /**
             * Scrollable adjustments are based on the natural size
             */
            NATURAL,
        }
        /**
         * Used to control what selections users are allowed to make.
         */

        /**
         * Used to control what selections users are allowed to make.
         */
        export namespace SelectionMode {
            export const $gtype: GObject.GType<SelectionMode>;
        }

        enum SelectionMode {
            /**
             * No selection is possible.
             */
            NONE,
            /**
             * Zero or one element may be selected.
             */
            SINGLE,
            /**
             * Exactly one element is selected.
             *   In some circumstances, such as initially or during a search
             *   operation, it’s possible for no element to be selected with
             *   %GTK_SELECTION_BROWSE. What is really enforced is that the user
             *   can’t deselect a currently selected element except by selecting
             *   another element.
             */
            BROWSE,
            /**
             * Any number of elements may be selected.
             *   The Ctrl key may be used to enlarge the selection, and Shift
             *   key to select between the focus and the child pointed to.
             *   Some widgets may also allow Click-drag to select a range of elements.
             */
            MULTIPLE,
        }
        /**
         * Determines how GTK handles the sensitivity of various controls,
         * such as combo box buttons.
         */

        /**
         * Determines how GTK handles the sensitivity of various controls,
         * such as combo box buttons.
         */
        export namespace SensitivityType {
            export const $gtype: GObject.GType<SensitivityType>;
        }

        enum SensitivityType {
            /**
             * The control is made insensitive if no
             *   action can be triggered
             */
            AUTO,
            /**
             * The control is always sensitive
             */
            ON,
            /**
             * The control is always insensitive
             */
            OFF,
        }
        /**
         * Describes where [class`Shortcut]`s added to a
         * [class`ShortcutController]` get handled.
         */

        /**
         * Describes where [class`Shortcut]`s added to a
         * [class`ShortcutController]` get handled.
         */
        export namespace ShortcutScope {
            export const $gtype: GObject.GType<ShortcutScope>;
        }

        enum ShortcutScope {
            /**
             * Shortcuts are handled inside
             *   the widget the controller belongs to.
             */
            LOCAL,
            /**
             * Shortcuts are handled by
             *   the first ancestor that is a [iface`ShortcutManager]`
             */
            MANAGED,
            /**
             * Shortcuts are handled by
             *   the root widget.
             */
            GLOBAL,
        }
        /**
         * GtkShortcutType specifies the kind of shortcut that is being described.
         *
         * More values may be added to this enumeration over time.
         */

        /**
         * GtkShortcutType specifies the kind of shortcut that is being described.
         *
         * More values may be added to this enumeration over time.
         */
        export namespace ShortcutType {
            export const $gtype: GObject.GType<ShortcutType>;
        }

        enum ShortcutType {
            /**
             * The shortcut is a keyboard accelerator. The GtkShortcutsShortcut:accelerator
             *   property will be used.
             */
            ACCELERATOR,
            /**
             * The shortcut is a pinch gesture. GTK provides an icon and subtitle.
             */
            GESTURE_PINCH,
            /**
             * The shortcut is a stretch gesture. GTK provides an icon and subtitle.
             */
            GESTURE_STRETCH,
            /**
             * The shortcut is a clockwise rotation gesture. GTK provides an icon and subtitle.
             */
            GESTURE_ROTATE_CLOCKWISE,
            /**
             * The shortcut is a counterclockwise rotation gesture. GTK provides an icon and subtitle.
             */
            GESTURE_ROTATE_COUNTERCLOCKWISE,
            /**
             * The shortcut is a two-finger swipe gesture. GTK provides an icon and subtitle.
             */
            GESTURE_TWO_FINGER_SWIPE_LEFT,
            /**
             * The shortcut is a two-finger swipe gesture. GTK provides an icon and subtitle.
             */
            GESTURE_TWO_FINGER_SWIPE_RIGHT,
            /**
             * The shortcut is a gesture. The GtkShortcutsShortcut:icon property will be
             *   used.
             */
            GESTURE,
            /**
             * The shortcut is a swipe gesture. GTK provides an icon and subtitle.
             */
            GESTURE_SWIPE_LEFT,
            /**
             * The shortcut is a swipe gesture. GTK provides an icon and subtitle.
             */
            GESTURE_SWIPE_RIGHT,
        }
        /**
         * The mode of the size group determines the directions in which the size
         * group affects the requested sizes of its component widgets.
         */

        /**
         * The mode of the size group determines the directions in which the size
         * group affects the requested sizes of its component widgets.
         */
        export namespace SizeGroupMode {
            export const $gtype: GObject.GType<SizeGroupMode>;
        }

        enum SizeGroupMode {
            /**
             * group has no effect
             */
            NONE,
            /**
             * group affects horizontal requisition
             */
            HORIZONTAL,
            /**
             * group affects vertical requisition
             */
            VERTICAL,
            /**
             * group affects both horizontal and vertical requisition
             */
            BOTH,
        }
        /**
         * Specifies a preference for height-for-width or
         * width-for-height geometry management.
         */

        /**
         * Specifies a preference for height-for-width or
         * width-for-height geometry management.
         */
        export namespace SizeRequestMode {
            export const $gtype: GObject.GType<SizeRequestMode>;
        }

        enum SizeRequestMode {
            /**
             * Prefer height-for-width geometry management
             */
            HEIGHT_FOR_WIDTH,
            /**
             * Prefer width-for-height geometry management
             */
            WIDTH_FOR_HEIGHT,
            /**
             * Don’t trade height-for-width or width-for-height
             */
            CONSTANT_SIZE,
        }
        /**
         * Determines the direction of a sort.
         */

        /**
         * Determines the direction of a sort.
         */
        export namespace SortType {
            export const $gtype: GObject.GType<SortType>;
        }

        enum SortType {
            /**
             * Sorting is in ascending order.
             */
            ASCENDING,
            /**
             * Sorting is in descending order.
             */
            DESCENDING,
        }
        /**
         * Describes changes in a sorter in more detail and allows users
         * to optimize resorting.
         */

        /**
         * Describes changes in a sorter in more detail and allows users
         * to optimize resorting.
         */
        export namespace SorterChange {
            export const $gtype: GObject.GType<SorterChange>;
        }

        enum SorterChange {
            /**
             * The sorter change cannot be described
             *   by any of the other enumeration values
             */
            DIFFERENT,
            /**
             * The sort order was inverted. Comparisons
             *   that returned %GTK_ORDERING_SMALLER now return %GTK_ORDERING_LARGER
             *   and vice versa. Other comparisons return the same values as before.
             */
            INVERTED,
            /**
             * The sorter is less strict: Comparisons
             *   may now return %GTK_ORDERING_EQUAL that did not do so before.
             */
            LESS_STRICT,
            /**
             * The sorter is more strict: Comparisons
             *   that did return %GTK_ORDERING_EQUAL may not do so anymore.
             */
            MORE_STRICT,
        }
        /**
         * Describes the type of order that a `GtkSorter` may produce.
         */

        /**
         * Describes the type of order that a `GtkSorter` may produce.
         */
        export namespace SorterOrder {
            export const $gtype: GObject.GType<SorterOrder>;
        }

        enum SorterOrder {
            /**
             * A partial order. Any `GtkOrdering` is possible.
             */
            PARTIAL,
            /**
             * No order, all elements are considered equal.
             *   gtk_sorter_compare() will only return %GTK_ORDERING_EQUAL.
             */
            NONE,
            /**
             * A total order. gtk_sorter_compare() will only
             *   return %GTK_ORDERING_EQUAL if an item is compared with itself. Two
             *   different items will never cause this value to be returned.
             */
            TOTAL,
        }
        /**
         * Determines whether the spin button displays values outside the adjustment
         * bounds.
         *
         * See [method`Gtk`.SpinButton.set_update_policy].
         */

        /**
         * Determines whether the spin button displays values outside the adjustment
         * bounds.
         *
         * See [method`Gtk`.SpinButton.set_update_policy].
         */
        export namespace SpinButtonUpdatePolicy {
            export const $gtype: GObject.GType<SpinButtonUpdatePolicy>;
        }

        enum SpinButtonUpdatePolicy {
            /**
             * When refreshing your `GtkSpinButton`, the value is
             *   always displayed
             */
            ALWAYS,
            /**
             * When refreshing your `GtkSpinButton`, the value is
             *   only displayed if it is valid within the bounds of the spin button's
             *   adjustment
             */
            IF_VALID,
        }
        /**
         * The values of the GtkSpinType enumeration are used to specify the
         * change to make in gtk_spin_button_spin().
         */

        /**
         * The values of the GtkSpinType enumeration are used to specify the
         * change to make in gtk_spin_button_spin().
         */
        export namespace SpinType {
            export const $gtype: GObject.GType<SpinType>;
        }

        enum SpinType {
            /**
             * Increment by the adjustments step increment.
             */
            STEP_FORWARD,
            /**
             * Decrement by the adjustments step increment.
             */
            STEP_BACKWARD,
            /**
             * Increment by the adjustments page increment.
             */
            PAGE_FORWARD,
            /**
             * Decrement by the adjustments page increment.
             */
            PAGE_BACKWARD,
            /**
             * Go to the adjustments lower bound.
             */
            HOME,
            /**
             * Go to the adjustments upper bound.
             */
            END,
            /**
             * Change by a specified amount.
             */
            USER_DEFINED,
        }
        /**
         * Possible transitions between pages in a `GtkStack` widget.
         *
         * New values may be added to this enumeration over time.
         */

        /**
         * Possible transitions between pages in a `GtkStack` widget.
         *
         * New values may be added to this enumeration over time.
         */
        export namespace StackTransitionType {
            export const $gtype: GObject.GType<StackTransitionType>;
        }

        enum StackTransitionType {
            /**
             * No transition
             */
            NONE,
            /**
             * A cross-fade
             */
            CROSSFADE,
            /**
             * Slide from left to right
             */
            SLIDE_RIGHT,
            /**
             * Slide from right to left
             */
            SLIDE_LEFT,
            /**
             * Slide from bottom up
             */
            SLIDE_UP,
            /**
             * Slide from top down
             */
            SLIDE_DOWN,
            /**
             * Slide from left or right according to the children order
             */
            SLIDE_LEFT_RIGHT,
            /**
             * Slide from top down or bottom up according to the order
             */
            SLIDE_UP_DOWN,
            /**
             * Cover the old page by sliding up
             */
            OVER_UP,
            /**
             * Cover the old page by sliding down
             */
            OVER_DOWN,
            /**
             * Cover the old page by sliding to the left
             */
            OVER_LEFT,
            /**
             * Cover the old page by sliding to the right
             */
            OVER_RIGHT,
            /**
             * Uncover the new page by sliding up
             */
            UNDER_UP,
            /**
             * Uncover the new page by sliding down
             */
            UNDER_DOWN,
            /**
             * Uncover the new page by sliding to the left
             */
            UNDER_LEFT,
            /**
             * Uncover the new page by sliding to the right
             */
            UNDER_RIGHT,
            /**
             * Cover the old page sliding up or uncover the new page sliding down, according to order
             */
            OVER_UP_DOWN,
            /**
             * Cover the old page sliding down or uncover the new page sliding up, according to order
             */
            OVER_DOWN_UP,
            /**
             * Cover the old page sliding left or uncover the new page sliding right, according to order
             */
            OVER_LEFT_RIGHT,
            /**
             * Cover the old page sliding right or uncover the new page sliding left, according to order
             */
            OVER_RIGHT_LEFT,
            /**
             * Pretend the pages are sides of a cube and rotate that cube to the left
             */
            ROTATE_LEFT,
            /**
             * Pretend the pages are sides of a cube and rotate that cube to the right
             */
            ROTATE_RIGHT,
            /**
             * Pretend the pages are sides of a cube and rotate that cube to the left or right according to the children order
             */
            ROTATE_LEFT_RIGHT,
        }
        /**
         * Specifies how search strings are matched inside text.
         */

        /**
         * Specifies how search strings are matched inside text.
         */
        export namespace StringFilterMatchMode {
            export const $gtype: GObject.GType<StringFilterMatchMode>;
        }

        enum StringFilterMatchMode {
            /**
             * The search string and
             *   text must match exactly.
             */
            EXACT,
            /**
             * The search string
             *   must be contained as a substring inside the text.
             */
            SUBSTRING,
            /**
             * The text must begin
             *   with the search string.
             */
            PREFIX,
        }
        /**
         * The indexes of colors passed to symbolic color rendering, such as
         * [vfunc`Gtk`.SymbolicPaintable.snapshot_symbolic].
         *
         * More values may be added over time.
         */

        /**
         * The indexes of colors passed to symbolic color rendering, such as
         * [vfunc`Gtk`.SymbolicPaintable.snapshot_symbolic].
         *
         * More values may be added over time.
         */
        export namespace SymbolicColor {
            export const $gtype: GObject.GType<SymbolicColor>;
        }

        enum SymbolicColor {
            /**
             * The default foreground color
             */
            FOREGROUND,
            /**
             * Indication color for errors
             */
            ERROR,
            /**
             * Indication color for warnings
             */
            WARNING,
            /**
             * Indication color for success
             */
            SUCCESS,
        }
        /**
         * Values that can be passed to the [vfunc`Gtk`.Widget.system_setting_changed]
         * vfunc.
         *
         * The values indicate which system setting has changed.
         * Widgets may need to drop caches, or react otherwise.
         *
         * Most of the values correspond to [class`Settings]` properties.
         *
         * More values may be added over time.
         */

        /**
         * Values that can be passed to the [vfunc`Gtk`.Widget.system_setting_changed]
         * vfunc.
         *
         * The values indicate which system setting has changed.
         * Widgets may need to drop caches, or react otherwise.
         *
         * Most of the values correspond to [class`Settings]` properties.
         *
         * More values may be added over time.
         */
        export namespace SystemSetting {
            export const $gtype: GObject.GType<SystemSetting>;
        }

        enum SystemSetting {
            /**
             * the [property`Gtk`.Settings:gtk-xft-dpi] setting has changed
             */
            DPI,
            /**
             * The [property`Gtk`.Settings:gtk-font-name] setting has changed
             */
            FONT_NAME,
            /**
             * The font configuration has changed in a way that
             *   requires text to be redrawn. This can be any of the
             *   [property`Gtk`.Settings:gtk-xft-antialias],
             *   [property`Gtk`.Settings:gtk-xft-hinting],
             *   [property`Gtk`.Settings:gtk-xft-hintstyle],
             *   [property`Gtk`.Settings:gtk-xft-rgba] or
             *   [property`Gtk`.Settings:gtk-fontconfig-timestamp] settings
             */
            FONT_CONFIG,
            /**
             * The display has changed
             */
            DISPLAY,
            /**
             * The icon theme has changed in a way that requires
             *   icons to be looked up again
             */
            ICON_THEME,
        }
        /**
         * Reading directions for text.
         */

        /**
         * Reading directions for text.
         */
        export namespace TextDirection {
            export const $gtype: GObject.GType<TextDirection>;
        }

        enum TextDirection {
            /**
             * No direction.
             */
            NONE,
            /**
             * Left to right text direction.
             */
            LTR,
            /**
             * Right to left text direction.
             */
            RTL,
        }
        /**
         * Granularity types that extend the text selection. Use the
         * `GtkTextView::extend-selection` signal to customize the selection.
         */

        /**
         * Granularity types that extend the text selection. Use the
         * `GtkTextView::extend-selection` signal to customize the selection.
         */
        export namespace TextExtendSelection {
            export const $gtype: GObject.GType<TextExtendSelection>;
        }

        enum TextExtendSelection {
            /**
             * Selects the current word. It is triggered by
             *   a double-click for example.
             */
            WORD,
            /**
             * Selects the current line. It is triggered by
             *   a triple-click for example.
             */
            LINE,
        }
        /**
         * Used to reference the layers of `GtkTextView` for the purpose of customized
         * drawing with the ::snapshot_layer vfunc.
         */

        /**
         * Used to reference the layers of `GtkTextView` for the purpose of customized
         * drawing with the ::snapshot_layer vfunc.
         */
        export namespace TextViewLayer {
            export const $gtype: GObject.GType<TextViewLayer>;
        }

        enum TextViewLayer {
            /**
             * The layer rendered below the text (but above the background).
             */
            BELOW_TEXT,
            /**
             * The layer rendered above the text.
             */
            ABOVE_TEXT,
        }
        /**
         * Used to reference the parts of `GtkTextView`.
         */

        /**
         * Used to reference the parts of `GtkTextView`.
         */
        export namespace TextWindowType {
            export const $gtype: GObject.GType<TextWindowType>;
        }

        enum TextWindowType {
            /**
             * Window that floats over scrolling areas.
             */
            WIDGET,
            /**
             * Scrollable text window.
             */
            TEXT,
            /**
             * Left side border window.
             */
            LEFT,
            /**
             * Right side border window.
             */
            RIGHT,
            /**
             * Top border window.
             */
            TOP,
            /**
             * Bottom border window.
             */
            BOTTOM,
        }
        /**
         * The sizing method the column uses to determine its width.  Please note
         * that %GTK_TREE_VIEW_COLUMN_AUTOSIZE are inefficient for large views, and
         * can make columns appear choppy.
         */

        /**
         * The sizing method the column uses to determine its width.  Please note
         * that %GTK_TREE_VIEW_COLUMN_AUTOSIZE are inefficient for large views, and
         * can make columns appear choppy.
         */
        export namespace TreeViewColumnSizing {
            export const $gtype: GObject.GType<TreeViewColumnSizing>;
        }

        enum TreeViewColumnSizing {
            /**
             * Columns only get bigger in reaction to changes in the model
             */
            GROW_ONLY,
            /**
             * Columns resize to be the optimal size every time the model changes.
             */
            AUTOSIZE,
            /**
             * Columns are a fixed numbers of pixels wide.
             */
            FIXED,
        }
        /**
         * An enum for determining where a dropped row goes.
         */

        /**
         * An enum for determining where a dropped row goes.
         */
        export namespace TreeViewDropPosition {
            export const $gtype: GObject.GType<TreeViewDropPosition>;
        }

        enum TreeViewDropPosition {
            /**
             * dropped row is inserted before
             */
            BEFORE,
            /**
             * dropped row is inserted after
             */
            AFTER,
            /**
             * dropped row becomes a child or is inserted before
             */
            INTO_OR_BEFORE,
            /**
             * dropped row becomes a child or is inserted after
             */
            INTO_OR_AFTER,
        }
        /**
         * Used to indicate which grid lines to draw in a tree view.
         */

        /**
         * Used to indicate which grid lines to draw in a tree view.
         */
        export namespace TreeViewGridLines {
            export const $gtype: GObject.GType<TreeViewGridLines>;
        }

        enum TreeViewGridLines {
            /**
             * No grid lines.
             */
            NONE,
            /**
             * Horizontal grid lines.
             */
            HORIZONTAL,
            /**
             * Vertical grid lines.
             */
            VERTICAL,
            /**
             * Horizontal and vertical grid lines.
             */
            BOTH,
        }
        /**
         * See also gtk_print_settings_set_paper_width().
         */

        /**
         * See also gtk_print_settings_set_paper_width().
         */
        export namespace Unit {
            export const $gtype: GObject.GType<Unit>;
        }

        enum Unit {
            /**
             * No units.
             */
            NONE,
            /**
             * Dimensions in points.
             */
            POINTS,
            /**
             * Dimensions in inches.
             */
            INCH,
            /**
             * Dimensions in millimeters
             */
            MM,
        }
        /**
         * Describes a type of line wrapping.
         */

        /**
         * Describes a type of line wrapping.
         */
        export namespace WrapMode {
            export const $gtype: GObject.GType<WrapMode>;
        }

        enum WrapMode {
            /**
             * do not wrap lines; just make the text area wider
             */
            NONE,
            /**
             * wrap text, breaking lines anywhere the cursor can
             *   appear (between characters, usually - if you want to be technical,
             *   between graphemes, see pango_get_log_attrs())
             */
            CHAR,
            /**
             * wrap text, breaking lines in between words
             */
            WORD,
            /**
             * wrap text, breaking lines in between words, or if
             *   that is not enough, also between graphemes
             */
            WORD_CHAR,
        }
        /**
         * An attribute for the background color, expressed as an RGB value
         * encoded in a string using the format: `{r8},{g8},{b8}`.
         */
        const ACCESSIBLE_ATTRIBUTE_BACKGROUND: string;
        /**
         * An attribute for the font family name.
         */
        const ACCESSIBLE_ATTRIBUTE_FAMILY: string;
        /**
         * An attribute for the foreground color, expressed as an RGB value
         * encoded in a string using the format: `{r8},{g8},{b8}`.
         */
        const ACCESSIBLE_ATTRIBUTE_FOREGROUND: string;
        /**
         * An attribute for the overline style.
         *
         * Possible values are:
         *
         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_OVERLINE_NONE]
         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_OVERLINE_SINGLE]
         */
        const ACCESSIBLE_ATTRIBUTE_OVERLINE: string;
        /**
         * The "none" overline value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_OVERLINE].
         */
        const ACCESSIBLE_ATTRIBUTE_OVERLINE_NONE: string;
        /**
         * The "single" overline value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_OVERLINE].
         */
        const ACCESSIBLE_ATTRIBUTE_OVERLINE_SINGLE: string;
        /**
         * An attribute for the font size, expressed in points.
         */
        const ACCESSIBLE_ATTRIBUTE_SIZE: string;
        /**
         * An attribute for the font stretch type.
         *
         * Possible values are:
         *
         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH_ULTRA_CONDENSED]
         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH_EXTRA_CONDENSED]
         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH_CONDENSED]
         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH_SEMI_CONDENSED]
         */
        const ACCESSIBLE_ATTRIBUTE_STRETCH: string;
        /**
         * The "condensed" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
         */
        const ACCESSIBLE_ATTRIBUTE_STRETCH_CONDENSED: string;
        /**
         * The "expanded" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
         */
        const ACCESSIBLE_ATTRIBUTE_STRETCH_EXPANDED: string;
        /**
         * The "extra condensed" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
         */
        const ACCESSIBLE_ATTRIBUTE_STRETCH_EXTRA_CONDENSED: string;
        /**
         * The "extra expanded" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
         */
        const ACCESSIBLE_ATTRIBUTE_STRETCH_EXTRA_EXPANDED: string;
        /**
         * The "normal" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
         */
        const ACCESSIBLE_ATTRIBUTE_STRETCH_NORMAL: string;
        /**
         * The "semi condensed" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
         */
        const ACCESSIBLE_ATTRIBUTE_STRETCH_SEMI_CONDENSED: string;
        /**
         * The "semi expanded" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
         */
        const ACCESSIBLE_ATTRIBUTE_STRETCH_SEMI_EXPANDED: string;
        /**
         * The "ultra condensed" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
         */
        const ACCESSIBLE_ATTRIBUTE_STRETCH_ULTRA_CONDENSED: string;
        /**
         * The "ultra expanded" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
         */
        const ACCESSIBLE_ATTRIBUTE_STRETCH_ULTRA_EXPANDED: string;
        /**
         * An attribute for strikethrough text.
         *
         * Possible values are `true` or `false`.
         */
        const ACCESSIBLE_ATTRIBUTE_STRIKETHROUGH: string;
        /**
         * An attribute for the font style.
         *
         * Possible values are:
         *
         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STYLE_NORMAL]
         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STYLE_OBLIQUE]
         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STYLE_ITALIC]
         */
        const ACCESSIBLE_ATTRIBUTE_STYLE: string;
        /**
         * The "italic" style value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STYLE].
         */
        const ACCESSIBLE_ATTRIBUTE_STYLE_ITALIC: string;
        /**
         * The "normal" style value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STYLE].
         */
        const ACCESSIBLE_ATTRIBUTE_STYLE_NORMAL: string;
        /**
         * The "oblique" style value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STYLE].
         */
        const ACCESSIBLE_ATTRIBUTE_STYLE_OBLIQUE: string;
        /**
         * An attribute for the underline style.
         *
         * Possible values are:
         *
         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE_NONE]
         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE_SINGLE]
         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE_DOUBLE]
         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE_ERROR]
         */
        const ACCESSIBLE_ATTRIBUTE_UNDERLINE: string;
        /**
         * The "double" underline value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE].
         */
        const ACCESSIBLE_ATTRIBUTE_UNDERLINE_DOUBLE: string;
        /**
         * The "error" underline value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE].
         */
        const ACCESSIBLE_ATTRIBUTE_UNDERLINE_ERROR: string;
        /**
         * The "none" underline value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE].
         */
        const ACCESSIBLE_ATTRIBUTE_UNDERLINE_NONE: string;
        /**
         * The "single" underline value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE].
         */
        const ACCESSIBLE_ATTRIBUTE_UNDERLINE_SINGLE: string;
        /**
         * An attribute for the font variant.
         *
         * Possible values are:
         *
         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT_SMALL_CAPS]
         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_SMALL_CAPS]
         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT_PETITE_CAPS]
         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_PETITE_CAPS]
         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT_UNICASE]
         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT_TITLE_CAPS]
         */
        const ACCESSIBLE_ATTRIBUTE_VARIANT: string;
        /**
         * The "all petite caps" variant value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT].
         */
        const ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_PETITE_CAPS: string;
        /**
         * The "all small caps" variant value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT].
         */
        const ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_SMALL_CAPS: string;
        /**
         * The "petite caps" variant value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT].
         */
        const ACCESSIBLE_ATTRIBUTE_VARIANT_PETITE_CAPS: string;
        /**
         * The "small caps" variant value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT].
         */
        const ACCESSIBLE_ATTRIBUTE_VARIANT_SMALL_CAPS: string;
        /**
         * The "title caps" variant value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT].
         */
        const ACCESSIBLE_ATTRIBUTE_VARIANT_TITLE_CAPS: string;
        /**
         * The "unicase" variant value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT].
         */
        const ACCESSIBLE_ATTRIBUTE_VARIANT_UNICASE: string;
        /**
         * An attribute for the font weight.
         */
        const ACCESSIBLE_ATTRIBUTE_WEIGHT: string;
        /**
         * An undefined value. The accessible attribute is either unset, or its
         * value is undefined.
         */
        const ACCESSIBLE_VALUE_UNDEFINED: number;
        /**
         * Like [func`get_binary_age]`, but from the headers used at
         * application compile time, rather than from the library linked
         * against at application run time.
         */
        const BINARY_AGE: number;
        /**
         * The default name of the extension point.
         */
        const IM_MODULE_EXTENSION_POINT_NAME: string;
        /**
         * Constant to return from a signal handler for the ::input
         * signal in case of conversion failure.
         *
         * See [signal`Gtk`.SpinButton::input].
         */
        const INPUT_ERROR: number;
        /**
         * Like [func`get_interface_age]`, but from the headers used at
         * application compile time, rather than from the library linked
         * against at application run time.
         */
        const INTERFACE_AGE: number;
        /**
         * The value used to refer to a guaranteed invalid position
         * in a `GListModel`.
         *
         * This value may be returned from some functions, others may
         * accept it as input. Its interpretation may differ for different
         * functions.
         *
         * Refer to each function's documentation for if this value is
         * allowed and what it does.
         */
        const INVALID_LIST_POSITION: number;
        /**
         * The name used for the stock full offset included by `GtkLevelBar`.
         */
        const LEVEL_BAR_OFFSET_FULL: string;
        /**
         * The name used for the stock high offset included by `GtkLevelBar`.
         */
        const LEVEL_BAR_OFFSET_HIGH: string;
        /**
         * The name used for the stock low offset included by `GtkLevelBar`.
         */
        const LEVEL_BAR_OFFSET_LOW: string;
        /**
         * Like [func`get_major_version]`, but from the headers used at
         * application compile time, rather than from the library linked
         * against at application run time.
         */
        const MAJOR_VERSION: number;
        /**
         * Evaluates to the maximum length of a compose sequence.
         *
         * This macro is longer used by GTK.
         */
        const MAX_COMPOSE_LEN: number;
        /**
         * The default extension point name for media file.
         */
        const MEDIA_FILE_EXTENSION_POINT_NAME: string;
        /**
         * Like [func`get_micro_version]`, but from the headers used at
         * application compile time, rather than from the library linked
         * against at application run time.
         */
        const MICRO_VERSION: number;
        /**
         * Like [func`get_minor_version]`, but from the headers used at
         * application compile time, rather than from the library linked
         * against at application run time.
         */
        const MINOR_VERSION: number;
        /**
         * Name for the A3 paper size.
         */
        const PAPER_NAME_A3: string;
        /**
         * Name for the A4 paper size.
         */
        const PAPER_NAME_A4: string;
        /**
         * Name for the A5 paper size.
         */
        const PAPER_NAME_A5: string;
        /**
         * Name for the B5 paper size.
         */
        const PAPER_NAME_B5: string;
        /**
         * Name for the Executive paper size.
         */
        const PAPER_NAME_EXECUTIVE: string;
        /**
         * Name for the Legal paper size.
         */
        const PAPER_NAME_LEGAL: string;
        /**
         * Name for the Letter paper size.
         */
        const PAPER_NAME_LETTER: string;
        /**
         * The key used by the “Print to file” printer to store whether to collate the
         * printed pages.
         */
        const PRINT_SETTINGS_COLLATE: string;
        /**
         * The key used by the “Print to file” printer to store the default source.
         */
        const PRINT_SETTINGS_DEFAULT_SOURCE: string;
        /**
         * The key used by the “Print to file” printer to store the dither used.
         */
        const PRINT_SETTINGS_DITHER: string;
        /**
         * The key used by the “Print to file” printer to store whether to print the
         * output in duplex.
         */
        const PRINT_SETTINGS_DUPLEX: string;
        /**
         * The key used by the “Print to file” printer to store the finishings.
         */
        const PRINT_SETTINGS_FINISHINGS: string;
        /**
         * The key used by the “Print to file” printer to store the media type.
         *
         * The set of media types is defined in PWG 5101.1-2002 PWG.
         */
        const PRINT_SETTINGS_MEDIA_TYPE: string;
        /**
         * The key used by the “Print to file” printer to store the number of pages per
         * sheet.
         */
        const PRINT_SETTINGS_NUMBER_UP: string;
        /**
         * The key used by the “Print to file” printer to store the number of pages per
         * sheet in number-up mode.
         */
        const PRINT_SETTINGS_NUMBER_UP_LAYOUT: string;
        /**
         * The key used by the “Print to file” printer to store the number of copies.
         */
        const PRINT_SETTINGS_N_COPIES: string;
        /**
         * The key used by the “Print to file” printer to store the orientation.
         */
        const PRINT_SETTINGS_ORIENTATION: string;
        /**
         * The key used by the “Print to file” printer to store the file
         * name of the output without the path to the directory and the
         * file extension.
         */
        const PRINT_SETTINGS_OUTPUT_BASENAME: string;
        /**
         * The key used by the “Print to file” printer to store the output bin.
         */
        const PRINT_SETTINGS_OUTPUT_BIN: string;
        /**
         * The key used by the “Print to file” printer to store the
         * directory to which the output should be written.
         */
        const PRINT_SETTINGS_OUTPUT_DIR: string;
        /**
         * The key used by the “Print to file” printer to store the format
         * of the output. The supported values are “PS” and “PDF”.
         */
        const PRINT_SETTINGS_OUTPUT_FILE_FORMAT: string;
        /**
         * The key used by the “Print to file” printer to store the URI
         * to which the output should be written. GTK itself supports
         * only “file://” URIs.
         */
        const PRINT_SETTINGS_OUTPUT_URI: string;
        /**
         * The key used by the “Print to file” printer to store the array of page ranges
         * to print.
         */
        const PRINT_SETTINGS_PAGE_RANGES: string;
        /**
         * The key used by the “Print to file” printer to store the set of pages to print.
         */
        const PRINT_SETTINGS_PAGE_SET: string;
        /**
         * The key used by the “Print to file” printer to store the page format.
         */
        const PRINT_SETTINGS_PAPER_FORMAT: string;
        /**
         * The key used by the “Print to file” printer to store the page height.
         */
        const PRINT_SETTINGS_PAPER_HEIGHT: string;
        /**
         * The key used by the “Print to file” printer to store the paper width.
         */
        const PRINT_SETTINGS_PAPER_WIDTH: string;
        /**
         * The key used by the “Print to file” printer to store the printer name.
         */
        const PRINT_SETTINGS_PRINTER: string;
        /**
         * The key used by the “Print to file” printer to store the resolution in lines
         * per inch.
         */
        const PRINT_SETTINGS_PRINTER_LPI: string;
        /**
         * The key used by the “Print to file” printer to store which pages to print.
         */
        const PRINT_SETTINGS_PRINT_PAGES: string;
        /**
         * The key used by the “Print to file” printer to store the printing quality.
         */
        const PRINT_SETTINGS_QUALITY: string;
        /**
         * The key used by the “Print to file” printer to store the resolution in DPI.
         */
        const PRINT_SETTINGS_RESOLUTION: string;
        /**
         * The key used by the “Print to file” printer to store the horizontal
         * resolution in DPI.
         */
        const PRINT_SETTINGS_RESOLUTION_X: string;
        /**
         * The key used by the “Print to file” printer to store the vertical resolution
         * in DPI.
         */
        const PRINT_SETTINGS_RESOLUTION_Y: string;
        /**
         * The key used by the “Print to file” printer to store whether to reverse the
         * order of the printed pages.
         */
        const PRINT_SETTINGS_REVERSE: string;
        /**
         * The key used by the “Print to file” printer to store the scale.
         */
        const PRINT_SETTINGS_SCALE: string;
        /**
         * The key used by the “Print to file” printer to store whether to print with
         * colors.
         */
        const PRINT_SETTINGS_USE_COLOR: string;
        /**
         * The key used by the “Print to file” printer to store 32-bit Windows extra
         * driver.
         */
        const PRINT_SETTINGS_WIN32_DRIVER_EXTRA: string;
        /**
         * The key used by the “Print to file” printer to store the 32-bit Windows
         * driver version.
         */
        const PRINT_SETTINGS_WIN32_DRIVER_VERSION: string;
        /**
         * Use this priority for functionality related to size allocation.
         *
         * It is used internally by GTK+ to compute the sizes of widgets.
         * This priority is higher than %GDK_PRIORITY_REDRAW to avoid
         * resizing a widget which was just redrawn.
         */
        const PRIORITY_RESIZE: number;
        /**
         * A priority that can be used when adding a `GtkStyleProvider`
         * for application-specific style information.
         */
        const STYLE_PROVIDER_PRIORITY_APPLICATION: number;
        /**
         * The priority used for default style information
         * that is used in the absence of themes.
         *
         * Note that this is not very useful for providing default
         * styling for custom style classes - themes are likely to
         * override styling provided at this priority with
         * catch-all `* {...}` rules.
         */
        const STYLE_PROVIDER_PRIORITY_FALLBACK: number;
        /**
         * The priority used for style information provided
         * via `GtkSettings`.
         *
         * This priority is higher than %GTK_STYLE_PROVIDER_PRIORITY_THEME
         * to let settings override themes.
         */
        const STYLE_PROVIDER_PRIORITY_SETTINGS: number;
        /**
         * The priority used for style information provided
         * by themes.
         */
        const STYLE_PROVIDER_PRIORITY_THEME: number;
        /**
         * The priority used for the style information from
         * `$XDG_CONFIG_HOME/gtk-4.0/gtk.css`.
         *
         * You should not use priorities higher than this, to
         * give the user the last word.
         */
        const STYLE_PROVIDER_PRIORITY_USER: number;
        /**
         * The priority at which the text view validates onscreen lines
         * in an idle job in the background.
         */
        const TEXT_VIEW_PRIORITY_VALIDATE: number;
        /**
         * Uses the default sort function in a [iface`Gtk`.TreeSortable].
         *
         * See also: [method`Gtk`.TreeSortable.set_sort_column_id]
         */
        const TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: number;
        /**
         * Disables sorting in a [iface`Gtk`.TreeSortable].
         *
         * See also: [method`Gtk`.TreeSortable.set_sort_column_id]
         */
        const TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: number;
        /**
         * Gets the modifier mask.
         *
         * The modifier mask determines which modifiers are considered significant
         * for keyboard accelerators. This includes all keyboard modifiers except
         * for %GDK_LOCK_MASK.
         * @returns the modifier mask for accelerators
         */
        function accelerator_get_default_mod_mask(): Gdk.ModifierType;
        /**
         * Converts an accelerator keyval and modifier mask into a string
         * which can be used to represent the accelerator to the user.
         * @param accelerator_key accelerator keyval
         * @param accelerator_mods accelerator modifier mask
         * @returns a newly-allocated string representing the accelerator
         */
        function accelerator_get_label(accelerator_key: number, accelerator_mods: Gdk.ModifierType | null): string;
        /**
         * Converts an accelerator keyval and modifier mask
         * into a string that can be displayed to the user.
         *
         * The string may be translated.
         *
         * This function is similar to [func`Gtk`.accelerator_get_label],
         * but handling keycodes. This is only useful for system-level
         * components, applications should use [func`Gtk`.accelerator_get_label]
         * instead.
         * @param display a `GdkDisplay` or %NULL to use the default display
         * @param accelerator_key accelerator keyval
         * @param keycode accelerator keycode
         * @param accelerator_mods accelerator modifier mask
         * @returns a newly-allocated string representing the accelerator
         */
        function accelerator_get_label_with_keycode(
            display: Gdk.Display | null,
            accelerator_key: number,
            keycode: number,
            accelerator_mods: Gdk.ModifierType | null,
        ): string;
        /**
         * Converts an accelerator keyval and modifier mask into a string
         * parseable by gtk_accelerator_parse().
         *
         * For example, if you pass in %GDK_KEY_q and %GDK_CONTROL_MASK,
         * this function returns `<Control>q`.
         *
         * If you need to display accelerators in the user interface,
         * see [func`Gtk`.accelerator_get_label].
         * @param accelerator_key accelerator keyval
         * @param accelerator_mods accelerator modifier mask
         * @returns a newly-allocated accelerator name
         */
        function accelerator_name(accelerator_key: number, accelerator_mods: Gdk.ModifierType | null): string;
        /**
         * Converts an accelerator keyval and modifier mask
         * into a string parseable by gtk_accelerator_parse_with_keycode().
         *
         * This is similar to [func`Gtk`.accelerator_name] but handling keycodes.
         * This is only useful for system-level components, applications
         * should use [func`Gtk`.accelerator_name] instead.
         * @param display a `GdkDisplay` or %NULL to use the default display
         * @param accelerator_key accelerator keyval
         * @param keycode accelerator keycode
         * @param accelerator_mods accelerator modifier mask
         * @returns a newly allocated accelerator name.
         */
        function accelerator_name_with_keycode(
            display: Gdk.Display | null,
            accelerator_key: number,
            keycode: number,
            accelerator_mods: Gdk.ModifierType | null,
        ): string;
        /**
         * Parses a string representing an accelerator.
         *
         * The format looks like “`<Control>a`” or “`<Shift><Alt>F1`”.
         *
         * The parser is fairly liberal and allows lower or upper case, and also
         * abbreviations such as “`<Ctl>`” and “`<Ctrl>`”.
         *
         * Key names are parsed using [func`Gdk`.keyval_from_name]. For character keys
         * the name is not the symbol, but the lowercase name, e.g. one would use
         * “`<Ctrl>minus`” instead of “`<Ctrl>-`”.
         *
         * Modifiers are enclosed in angular brackets `<>`, and match the
         * [flags`Gdk`.ModifierType] mask:
         *
         * - `<Shift>` for `GDK_SHIFT_MASK`
         * - `<Ctrl>` for `GDK_CONTROL_MASK`
         * - `<Alt>` for `GDK_ALT_MASK`
         * - `<Meta>` for `GDK_META_MASK`
         * - `<Super>` for `GDK_SUPER_MASK`
         * - `<Hyper>` for `GDK_HYPER_MASK`
         *
         * If the parse operation fails, `accelerator_key` and `accelerator_mods` will
         * be set to 0 (zero).
         * @param accelerator string representing an accelerator
         * @returns whether parsing succeeded
         */
        function accelerator_parse(accelerator: string): [boolean, number, Gdk.ModifierType | null];
        /**
         * Parses a string representing an accelerator.
         *
         * This is similar to [func`Gtk`.accelerator_parse] but handles keycodes as
         * well. This is only useful for system-level components, applications should
         * use [func`Gtk`.accelerator_parse] instead.
         *
         * If `accelerator_codes` is given and the result stored in it is non-%NULL,
         * the result must be freed with g_free().
         *
         * If a keycode is present in the accelerator and no `accelerator_codes`
         * is given, the parse will fail.
         *
         * If the parse fails, `accelerator_key,` `accelerator_mods` and
         * `accelerator_codes` will be set to 0 (zero).
         * @param accelerator string representing an accelerator
         * @param display the `GdkDisplay` to look up @accelerator_codes in
         * @returns %TRUE if parsing succeeded
         */
        function accelerator_parse_with_keycode(
            accelerator: string,
            display: Gdk.Display | null,
        ): [boolean, number, number[] | null, Gdk.ModifierType | null];
        /**
         * Determines whether a given keyval and modifier mask constitute
         * a valid keyboard accelerator.
         *
         * For example, the %GDK_KEY_a keyval plus %GDK_CONTROL_MASK mark is valid,
         * and matches the “Ctrl+a” accelerator. But, you can't, for instance, use
         * the %GDK_KEY_Control_L keyval as an accelerator.
         * @param keyval a GDK keyval
         * @param modifiers modifier mask
         * @returns %TRUE if the accelerator is valid
         */
        function accelerator_valid(keyval: number, modifiers: Gdk.ModifierType | null): boolean;
        /**
         * Initializes `value` with the appropriate type for the `property`.
         *
         * This function is mostly meant for language bindings, in conjunction
         * with gtk_accessible_update_property_value().
         * @param property a `GtkAccessibleProperty`
         * @param value an uninitialized `GValue`
         */
        function accessible_property_init_value(property: AccessibleProperty | null, value: GObject.Value | any): void;
        /**
         * Initializes `value` with the appropriate type for the `relation`.
         *
         * This function is mostly meant for language bindings, in conjunction
         * with gtk_accessible_update_relation_value().
         * @param relation a `GtkAccessibleRelation`
         * @param value an uninitialized `GValue`
         */
        function accessible_relation_init_value(relation: AccessibleRelation | null, value: GObject.Value | any): void;
        /**
         * Initializes `value` with the appropriate type for the `state`.
         *
         * This function is mostly meant for language bindings, in conjunction
         * with gtk_accessible_update_relation_state().
         * @param state a `GtkAccessibleState`
         * @param value an uninitialized `GValue`
         */
        function accessible_state_init_value(state: AccessibleState | null, value: GObject.Value | any): void;
        /**
         * Initializes `iter` to point to `target`.
         *
         * If `target` is not found, finds the next value after it.
         * If no value >= `target` exists in `set,` this function returns %FALSE.
         * @param set a `GtkBitset`
         * @param target target value to start iterating at
         * @returns %TRUE if a value was found.
         */
        function bitset_iter_init_at(set: Bitset, target: number): [boolean, BitsetIter, number];
        /**
         * Initializes an iterator for `set` and points it to the first
         * value in `set`.
         *
         * If `set` is empty, %FALSE is returned and `value` is set to %G_MAXUINT.
         * @param set a `GtkBitset`
         * @returns %TRUE if @set isn't empty.
         */
        function bitset_iter_init_first(set: Bitset): [boolean, BitsetIter, number];
        /**
         * Initializes an iterator for `set` and points it to the last
         * value in `set`.
         *
         * If `set` is empty, %FALSE is returned.
         * @param set a `GtkBitset`
         * @returns %TRUE if @set isn't empty.
         */
        function bitset_iter_init_last(set: Bitset): [boolean, BitsetIter, number];
        /**
         * Registers an error quark for [class`Gtk`.Builder] errors.
         * @returns the error quark
         */
        function builder_error_quark(): GLib.Quark;
        /**
         * Checks that the GTK library in use is compatible with the
         * given version.
         *
         * Generally you would pass in the constants %GTK_MAJOR_VERSION,
         * %GTK_MINOR_VERSION, %GTK_MICRO_VERSION as the three arguments
         * to this function; that produces a check that the library in
         * use is compatible with the version of GTK the application or
         * module was compiled against.
         *
         * Compatibility is defined by two things: first the version
         * of the running library is newer than the version
         * `required_major`.required_minor.`required_micro`. Second
         * the running library must be binary compatible with the
         * version `required_major`.required_minor.`required_micro`
         * (same major version.)
         *
         * This function is primarily for GTK modules; the module
         * can call this function to check that it wasn’t loaded
         * into an incompatible version of GTK. However, such a
         * check isn’t completely reliable, since the module may be
         * linked against an old version of GTK and calling the
         * old version of gtk_check_version(), but still get loaded
         * into an application using a newer version of GTK.
         * @param required_major the required major version
         * @param required_minor the required minor version
         * @param required_micro the required micro version
         * @returns %NULL if the GTK library is compatible with the   given version, or a string describing the version mismatch.   The returned string is owned by GTK and should not be modified   or freed.
         */
        function check_version(required_major: number, required_minor: number, required_micro: number): string | null;
        /**
         * Registers an error quark for VFL error parsing.
         * @returns the error quark
         */
        function constraint_vfl_parser_error_quark(): GLib.Quark;
        /**
         * Registers an error quark for CSS parsing errors.
         * @returns the error quark
         */
        function css_parser_error_quark(): GLib.Quark;
        /**
         * Registers an error quark for CSS parsing warnings.
         * @returns the warning quark
         */
        function css_parser_warning_quark(): GLib.Quark;
        /**
         * Registers an error quark for an operation that requires a dialog if
         * necessary.
         * @returns the error quark
         */
        function dialog_error_quark(): GLib.Quark;
        /**
         * Prevents [func`Gtk`.init] and [func`Gtk`.init_check] from automatically calling
         * `setlocale (LC_ALL, "")`.
         *
         * You would want to use this function if you wanted to set the locale for
         * your program to something other than the user’s locale, or if
         * you wanted to set different values for different locale categories.
         *
         * Most programs should not need to call this function.
         */
        function disable_setlocale(): void;
        /**
         * Distributes `extra_space` to child `sizes` by bringing smaller
         * children up to natural size first.
         *
         * The remaining space will be added to the `minimum_size` member of the
         * `GtkRequestedSize` struct. If all sizes reach their natural size then
         * the remaining space is returned.
         * @param extra_space Extra space to redistribute among children after subtracting   minimum sizes and any child padding from the overall allocation
         * @param sizes An array of structs with a client pointer and a minimum/natural size  in the orientation of the allocation.
         * @returns The remainder of @extra_space after redistributing space to @sizes.
         */
        function distribute_natural_allocation(extra_space: number, sizes: RequestedSize[]): number;
        /**
         * Gets a property of the `GtkEditable` delegate for `object`.
         *
         * This is helper function that should be called in the `get_property`
         * function of your `GtkEditable` implementation, before handling your
         * own properties.
         * @param object a `GObject`
         * @param prop_id a property ID
         * @param value value to set
         * @param pspec the `GParamSpec` for the property
         * @returns %TRUE if the property was found
         */
        function editable_delegate_get_property(
            object: GObject.Object,
            prop_id: number,
            value: GObject.Value | any,
            pspec: GObject.ParamSpec,
        ): boolean;
        /**
         * Sets a property on the `GtkEditable` delegate for `object`.
         *
         * This is a helper function that should be called in the `set_property`
         * function of your `GtkEditable` implementation, before handling your
         * own properties.
         * @param object a `GObject`
         * @param prop_id a property ID
         * @param value value to set
         * @param pspec the `GParamSpec` for the property
         * @returns %TRUE if the property was found
         */
        function editable_delegate_set_property(
            object: GObject.Object,
            prop_id: number,
            value: GObject.Value | any,
            pspec: GObject.ParamSpec,
        ): boolean;
        /**
         * Overrides the `GtkEditable` properties for `class`.
         *
         * This is a helper function that should be called in class_init,
         * after installing your own properties.
         *
         * Note that your class must have "text", "cursor-position",
         * "selection-bound", "editable", "width-chars", "max-width-chars",
         * "xalign" and "enable-undo" properties for this function to work.
         *
         * To handle the properties in your set_property and get_property
         * functions, you can either use [func`Gtk`.Editable.delegate_set_property]
         * and [func`Gtk`.Editable.delegate_get_property] (if you are using
         * a delegate), or remember the `first_prop` offset and add it to the
         * values in the [enum`Gtk`.EditableProperties] enumeration to get the
         * property IDs for these properties.
         * @param object_class a `GObjectClass`
         * @param first_prop property ID to use for the first property
         * @returns the number of properties that were installed
         */
        function editable_install_properties(object_class: typeof GObject.Object, first_prop: number): number;
        /**
         * Calls a function for all `GtkPrinter`s.
         *
         * If `func` returns %TRUE, the enumeration is stopped.
         * @param func a function to call for each printer
         * @param wait if %TRUE, wait in a recursive mainloop until    all printers are enumerated; otherwise return early
         */
        function enumerate_printers(func: PrinterFunc, wait: boolean): void;
        /**
         * Registers an error quark for `GtkFileChooser` errors.
         * @returns The error quark used for `GtkFileChooser` errors.
         */
        function file_chooser_error_quark(): GLib.Quark;
        /**
         * Returns the binary age as passed to `libtool`.
         *
         * If `libtool` means nothing to you, don't worry about it.
         * @returns the binary age of the GTK library
         */
        function get_binary_age(): number;
        /**
         * Returns the GTK debug flags that are currently active.
         *
         * This function is intended for GTK modules that want
         * to adjust their debug output based on GTK debug flags.
         * @returns the GTK debug flags.
         */
        function get_debug_flags(): DebugFlags;
        /**
         * Returns the `PangoLanguage` for the default language
         * currently in effect.
         *
         * Note that this can change over the life of an
         * application.
         *
         * The default language is derived from the current
         * locale. It determines, for example, whether GTK uses
         * the right-to-left or left-to-right text direction.
         *
         * This function is equivalent to [func`Pango`.Language.get_default].
         * See that function for details.
         * @returns the default language
         */
        function get_default_language(): Pango.Language;
        /**
         * Returns the interface age as passed to `libtool`.
         *
         * If `libtool` means nothing to you, don't worry about it.
         * @returns the interface age of the GTK library
         */
        function get_interface_age(): number;
        /**
         * Get the direction of the current locale. This is the expected
         * reading direction for text and UI.
         *
         * This function depends on the current locale being set with
         * setlocale() and will default to setting the %GTK_TEXT_DIR_LTR
         * direction otherwise. %GTK_TEXT_DIR_NONE will never be returned.
         *
         * GTK sets the default text direction according to the locale
         * during gtk_init(), and you should normally use
         * gtk_widget_get_direction() or gtk_widget_get_default_direction()
         * to obtain the current direction.
         *
         * This function is only needed rare cases when the locale is
         * changed after GTK has already been initialized. In this case,
         * you can use it to update the default text direction as follows:
         *
         *
         * ```c
         * #include <locale.h>
         *
         * static void
         * update_locale (const char *new_locale)
         * {
         *   setlocale (LC_ALL, new_locale);
         *   gtk_widget_set_default_direction (gtk_get_locale_direction ());
         * }
         * ```
         *
         * @returns the direction of the current locale
         */
        function get_locale_direction(): TextDirection;
        /**
         * Returns the major version number of the GTK library.
         *
         * For example, in GTK version 3.1.5 this is 3.
         *
         * This function is in the library, so it represents the GTK library
         * your code is running against. Contrast with the %GTK_MAJOR_VERSION
         * macro, which represents the major version of the GTK headers you
         * have included when compiling your code.
         * @returns the major version number of the GTK library
         */
        function get_major_version(): number;
        /**
         * Returns the micro version number of the GTK library.
         *
         * For example, in GTK version 3.1.5 this is 5.
         *
         * This function is in the library, so it represents the GTK library
         * your code is are running against. Contrast with the
         * %GTK_MICRO_VERSION macro, which represents the micro version of the
         * GTK headers you have included when compiling your code.
         * @returns the micro version number of the GTK library
         */
        function get_micro_version(): number;
        /**
         * Returns the minor version number of the GTK library.
         *
         * For example, in GTK version 3.1.5 this is 1.
         *
         * This function is in the library, so it represents the GTK library
         * your code is are running against. Contrast with the
         * %GTK_MINOR_VERSION macro, which represents the minor version of the
         * GTK headers you have included when compiling your code.
         * @returns the minor version number of the GTK library
         */
        function get_minor_version(): number;
        /**
         * Converts a color from HSV space to RGB.
         *
         * Input values must be in the [0.0, 1.0] range;
         * output values will be in the same range.
         * @param h Hue
         * @param s Saturation
         * @param v Value
         */
        function hsv_to_rgb(h: number, s: number, v: number): [number, number, number];
        /**
         * Registers an error quark for [class`Gtk`.IconTheme] errors.
         * @returns the error quark
         */
        function icon_theme_error_quark(): GLib.Quark;
        /**
         * Call this function before using any other GTK functions in your GUI
         * applications. It will initialize everything needed to operate the
         * toolkit.
         *
         * If you are using `GtkApplication`, you usually don't have to call this
         * function; the `GApplication::startup` handler does it for you. Though,
         * if you are using GApplication methods that will be invoked before `startup`,
         * such as `local_command_line`, you may need to initialize stuff explicitly.
         *
         * This function will terminate your program if it was unable to
         * initialize the windowing system for some reason. If you want
         * your program to fall back to a textual interface, call
         * [func`Gtk`.init_check] instead.
         *
         * GTK calls `signal (SIGPIPE, SIG_IGN)` during initialization, to ignore
         * SIGPIPE signals, since these are almost never wanted in graphical
         * applications. If you do need to handle SIGPIPE for some reason, reset
         * the handler after gtk_init(), but notice that other libraries (e.g.
         * libdbus or gvfs) might do similar things.
         */
        function init(): void;
        /**
         * This function does the same work as gtk_init() with only a single
         * change: It does not terminate the program if the windowing system
         * can’t be initialized. Instead it returns %FALSE on failure.
         *
         * This way the application can fall back to some other means of
         * communication with the user - for example a curses or command line
         * interface.
         * @returns %TRUE if the windowing system has been successfully   initialized, %FALSE otherwise
         */
        function init_check(): boolean;
        /**
         * Use this function to check if GTK has been initialized.
         *
         * See [func`Gtk`.init].
         * @returns the initialization status
         */
        function is_initialized(): boolean;
        /**
         * Finds the `GtkNative` associated with the surface.
         * @param surface a `GdkSurface`
         * @returns the `GtkNative` that is associated with @surface
         */
        function native_get_for_surface(surface: Gdk.Surface): Native | null;
        /**
         * Returns the name of the default paper size, which
         * depends on the current locale.
         * @returns the name of the default paper size. The string is owned by GTK and should not be modified.
         */
        function paper_size_get_default(): string;
        /**
         * Creates a list of known paper sizes.
         * @param include_custom whether to include custom paper sizes   as defined in the page setup dialog
         * @returns a newly allocated list of newly    allocated `GtkPaperSize` objects
         */
        function paper_size_get_paper_sizes(include_custom: boolean): PaperSize[];
        /**
         * Creates a new `GParamSpec` instance for a property holding a `GtkExpression`.
         *
         * See `g_param_spec_internal()` for details on the property strings.
         * @param name canonical name of the property
         * @param nick a user-readable name for the property
         * @param blurb a user-readable description of the property
         * @param flags flags for the property
         * @returns a newly created property specification
         */
        function param_spec_expression(
            name: string,
            nick: string,
            blurb: string,
            flags: GObject.ParamFlags | null,
        ): GObject.ParamSpec;
        /**
         * Registers an error quark for `GtkPrintOperation` if necessary.
         * @returns The error quark used for `GtkPrintOperation` errors.
         */
        function print_error_quark(): GLib.Quark;
        /**
         * Runs a page setup dialog, letting the user modify the values from
         * `page_setup`. If the user cancels the dialog, the returned `GtkPageSetup`
         * is identical to the passed in `page_setup,` otherwise it contains the
         * modifications done in the dialog.
         *
         * Note that this function may use a recursive mainloop to show the page
         * setup dialog. See gtk_print_run_page_setup_dialog_async() if this is
         * a problem.
         * @param parent transient parent
         * @param page_setup an existing `GtkPageSetup`
         * @param settings a `GtkPrintSettings`
         * @returns a new `GtkPageSetup`
         */
        function print_run_page_setup_dialog(
            parent: Window | null,
            page_setup: PageSetup | null,
            settings: PrintSettings,
        ): PageSetup;
        /**
         * Runs a page setup dialog, letting the user modify the values from `page_setup`.
         *
         * In contrast to gtk_print_run_page_setup_dialog(), this function  returns after
         * showing the page setup dialog on platforms that support this, and calls `done_cb`
         * from a signal handler for the ::response signal of the dialog.
         * @param parent transient parent
         * @param page_setup an existing `GtkPageSetup`
         * @param settings a `GtkPrintSettings`
         * @param done_cb a function to call when the user saves    the modified page setup
         */
        function print_run_page_setup_dialog_async(
            parent: Window | null,
            page_setup: PageSetup | null,
            settings: PrintSettings,
            done_cb: PageSetupDoneFunc,
        ): void;
        /**
         * Registers an error quark for [class`RecentManager]` errors.
         * @returns the error quark
         */
        function recent_manager_error_quark(): GLib.Quark;
        /**
         * Renders an activity indicator (such as in `GtkSpinner`).
         * The state %GTK_STATE_FLAG_CHECKED determines whether there is
         * activity going on.
         * @param context a `GtkStyleContext`
         * @param cr a `cairo_t`
         * @param x X origin of the rectangle
         * @param y Y origin of the rectangle
         * @param width rectangle width
         * @param height rectangle height
         */
        function render_activity(
            context: StyleContext,
            cr: cairo.Context,
            x: number,
            y: number,
            width: number,
            height: number,
        ): void;
        /**
         * Renders an arrow pointing to `angle`.
         *
         * Typical arrow rendering at 0, 1⁄2 π;, π; and 3⁄2 π:
         *
         * ![](arrows.png)
         * @param context a `GtkStyleContext`
         * @param cr a `cairo_t`
         * @param angle arrow angle from 0 to 2 * %G_PI, being 0 the arrow pointing to the north
         * @param x X origin of the render area
         * @param y Y origin of the render area
         * @param size square side for render area
         */
        function render_arrow(
            context: StyleContext,
            cr: cairo.Context,
            angle: number,
            x: number,
            y: number,
            size: number,
        ): void;
        /**
         * Renders the background of an element.
         *
         * Typical background rendering, showing the effect of
         * `background-image`, `border-width` and `border-radius`:
         *
         * ![](background.png)
         * @param context a `GtkStyleContext`
         * @param cr a `cairo_t`
         * @param x X origin of the rectangle
         * @param y Y origin of the rectangle
         * @param width rectangle width
         * @param height rectangle height
         */
        function render_background(
            context: StyleContext,
            cr: cairo.Context,
            x: number,
            y: number,
            width: number,
            height: number,
        ): void;
        /**
         * Renders a checkmark (as in a `GtkCheckButton`).
         *
         * The %GTK_STATE_FLAG_CHECKED state determines whether the check is
         * on or off, and %GTK_STATE_FLAG_INCONSISTENT determines whether it
         * should be marked as undefined.
         *
         * Typical checkmark rendering:
         *
         * ![](checks.png)
         * @param context a `GtkStyleContext`
         * @param cr a `cairo_t`
         * @param x X origin of the rectangle
         * @param y Y origin of the rectangle
         * @param width rectangle width
         * @param height rectangle height
         */
        function render_check(
            context: StyleContext,
            cr: cairo.Context,
            x: number,
            y: number,
            width: number,
            height: number,
        ): void;
        /**
         * Renders an expander (as used in `GtkTreeView` and `GtkExpander`) in the area
         * defined by `x,` `y,` `width,` `height`. The state %GTK_STATE_FLAG_CHECKED
         * determines whether the expander is collapsed or expanded.
         *
         * Typical expander rendering:
         *
         * ![](expanders.png)
         * @param context a `GtkStyleContext`
         * @param cr a `cairo_t`
         * @param x X origin of the rectangle
         * @param y Y origin of the rectangle
         * @param width rectangle width
         * @param height rectangle height
         */
        function render_expander(
            context: StyleContext,
            cr: cairo.Context,
            x: number,
            y: number,
            width: number,
            height: number,
        ): void;
        /**
         * Renders a focus indicator on the rectangle determined by `x,` `y,` `width,` `height`.
         *
         * Typical focus rendering:
         *
         * ![](focus.png)
         * @param context a `GtkStyleContext`
         * @param cr a `cairo_t`
         * @param x X origin of the rectangle
         * @param y Y origin of the rectangle
         * @param width rectangle width
         * @param height rectangle height
         */
        function render_focus(
            context: StyleContext,
            cr: cairo.Context,
            x: number,
            y: number,
            width: number,
            height: number,
        ): void;
        /**
         * Renders a frame around the rectangle defined by `x,` `y,` `width,` `height`.
         *
         * Examples of frame rendering, showing the effect of `border-image`,
         * `border-color`, `border-width`, `border-radius` and junctions:
         *
         * ![](frames.png)
         * @param context a `GtkStyleContext`
         * @param cr a `cairo_t`
         * @param x X origin of the rectangle
         * @param y Y origin of the rectangle
         * @param width rectangle width
         * @param height rectangle height
         */
        function render_frame(
            context: StyleContext,
            cr: cairo.Context,
            x: number,
            y: number,
            width: number,
            height: number,
        ): void;
        /**
         * Renders a handle (as in `GtkPaned` and `GtkWindow`’s resize grip),
         * in the rectangle determined by `x,` `y,` `width,` `height`.
         *
         * Handles rendered for the paned and grip classes:
         *
         * ![](handles.png)
         * @param context a `GtkStyleContext`
         * @param cr a `cairo_t`
         * @param x X origin of the rectangle
         * @param y Y origin of the rectangle
         * @param width rectangle width
         * @param height rectangle height
         */
        function render_handle(
            context: StyleContext,
            cr: cairo.Context,
            x: number,
            y: number,
            width: number,
            height: number,
        ): void;
        /**
         * Renders the icon in `texture` at the specified `x` and `y` coordinates.
         *
         * This function will render the icon in `texture` at exactly its size,
         * regardless of scaling factors, which may not be appropriate when
         * drawing on displays with high pixel densities.
         * @param context a `GtkStyleContext`
         * @param cr a `cairo_t`
         * @param texture a `GdkTexture` containing the icon to draw
         * @param x X position for the @texture
         * @param y Y position for the @texture
         */
        function render_icon(
            context: StyleContext,
            cr: cairo.Context,
            texture: Gdk.Texture,
            x: number,
            y: number,
        ): void;
        /**
         * Renders `layout` on the coordinates `x,` `y`
         * @param context a `GtkStyleContext`
         * @param cr a `cairo_t`
         * @param x X origin
         * @param y Y origin
         * @param layout the `PangoLayout` to render
         */
        function render_layout(
            context: StyleContext,
            cr: cairo.Context,
            x: number,
            y: number,
            layout: Pango.Layout,
        ): void;
        /**
         * Renders a line from (x0, y0) to (x1, y1).
         * @param context a `GtkStyleContext`
         * @param cr a `cairo_t`
         * @param x0 X coordinate for the origin of the line
         * @param y0 Y coordinate for the origin of the line
         * @param x1 X coordinate for the end of the line
         * @param y1 Y coordinate for the end of the line
         */
        function render_line(
            context: StyleContext,
            cr: cairo.Context,
            x0: number,
            y0: number,
            x1: number,
            y1: number,
        ): void;
        /**
         * Renders an option mark (as in a radio button), the %GTK_STATE_FLAG_CHECKED
         * state will determine whether the option is on or off, and
         * %GTK_STATE_FLAG_INCONSISTENT whether it should be marked as undefined.
         *
         * Typical option mark rendering:
         *
         * ![](options.png)
         * @param context a `GtkStyleContext`
         * @param cr a `cairo_t`
         * @param x X origin of the rectangle
         * @param y Y origin of the rectangle
         * @param width rectangle width
         * @param height rectangle height
         */
        function render_option(
            context: StyleContext,
            cr: cairo.Context,
            x: number,
            y: number,
            width: number,
            height: number,
        ): void;
        /**
         * Converts a color from RGB space to HSV.
         *
         * Input values must be in the [0.0, 1.0] range;
         * output values will be in the same range.
         * @param r Red
         * @param g Green
         * @param b Blue
         */
        function rgb_to_hsv(r: number, g: number, b: number): [number, number, number];
        /**
         * Sets the GTK debug flags.
         * @param flags the debug flags to set
         */
        function set_debug_flags(flags: DebugFlags | null): void;
        /**
         * This function launches the default application for showing
         * a given uri, or shows an error dialog if that fails.
         * @param parent parent window
         * @param uri the uri to show
         * @param timestamp timestamp from the event that triggered this call, or %GDK_CURRENT_TIME
         */
        function show_uri(parent: Window | null, uri: string, timestamp: number): void;
        /**
         * This function launches the default application for showing
         * a given uri.
         *
         * The `callback` will be called when the launch is completed.
         *
         * This is the recommended call to be used as it passes information
         * necessary for sandbox helpers to parent their dialogs properly.
         * @param parent parent window
         * @param uri the uri to show
         * @param timestamp timestamp from the event that triggered this call, or %GDK_CURRENT_TIME
         * @param cancellable a `GCancellable` to cancel the launch
         */
        function show_uri_full(
            parent: Window | null,
            uri: string,
            timestamp: number,
            cancellable?: Gio.Cancellable | null,
        ): Promise<boolean>;
        /**
         * This function launches the default application for showing
         * a given uri.
         *
         * The `callback` will be called when the launch is completed.
         *
         * This is the recommended call to be used as it passes information
         * necessary for sandbox helpers to parent their dialogs properly.
         * @param parent parent window
         * @param uri the uri to show
         * @param timestamp timestamp from the event that triggered this call, or %GDK_CURRENT_TIME
         * @param cancellable a `GCancellable` to cancel the launch
         * @param callback a callback to call when the action is complete
         */
        function show_uri_full(
            parent: Window | null,
            uri: string,
            timestamp: number,
            cancellable: Gio.Cancellable | null,
            callback: Gio.AsyncReadyCallback<Window | null> | null,
        ): void;
        /**
         * This function launches the default application for showing
         * a given uri.
         *
         * The `callback` will be called when the launch is completed.
         *
         * This is the recommended call to be used as it passes information
         * necessary for sandbox helpers to parent their dialogs properly.
         * @param parent parent window
         * @param uri the uri to show
         * @param timestamp timestamp from the event that triggered this call, or %GDK_CURRENT_TIME
         * @param cancellable a `GCancellable` to cancel the launch
         * @param callback a callback to call when the action is complete
         */
        function show_uri_full(
            parent: Window | null,
            uri: string,
            timestamp: number,
            cancellable?: Gio.Cancellable | null,
            callback?: Gio.AsyncReadyCallback<Window | null> | null,
        ): Promise<boolean> | void;
        /**
         * Finishes the gtk_show_uri() call and returns the result
         * of the operation.
         * @param parent the `GtkWindow` passed to gtk_show_uri()
         * @param result `GAsyncResult` that was passed to @callback
         * @returns %TRUE if the URI was shown successfully.   Otherwise, %FALSE is returned and @error is set
         */
        function show_uri_full_finish(parent: Window, result: Gio.AsyncResult): boolean;
        /**
         * Prints an assertion message for gtk_test_accessible_assert_role().
         * @param domain a domain
         * @param file a file name
         * @param line the line in @file
         * @param func a function name in @file
         * @param expr the expression being tested
         * @param accessible a `GtkAccessible`
         * @param expected_role the expected `GtkAccessibleRole`
         * @param actual_role the actual `GtkAccessibleRole`
         */
        function test_accessible_assertion_message_role(
            domain: string,
            file: string,
            line: number,
            func: string,
            expr: string,
            accessible: Accessible,
            expected_role: AccessibleRole | null,
            actual_role: AccessibleRole | null,
        ): void;
        /**
         * Checks whether the `GtkAccessible` has `property` set.
         * @param accessible a `GtkAccessible`
         * @param property a `GtkAccessibleProperty`
         * @returns %TRUE if the @property is set in the @accessible
         */
        function test_accessible_has_property(accessible: Accessible, property: AccessibleProperty | null): boolean;
        /**
         * Checks whether the `GtkAccessible` has `relation` set.
         * @param accessible a `GtkAccessible`
         * @param relation a `GtkAccessibleRelation`
         * @returns %TRUE if the @relation is set in the @accessible
         */
        function test_accessible_has_relation(accessible: Accessible, relation: AccessibleRelation | null): boolean;
        /**
         * Checks whether the `GtkAccessible:accessible-role` of the accessible
         * is `role`.
         * @param accessible a `GtkAccessible`
         * @param role a `GtkAccessibleRole`
         * @returns %TRUE if the role matches
         */
        function test_accessible_has_role(accessible: Accessible, role: AccessibleRole | null): boolean;
        /**
         * Checks whether the `GtkAccessible` has `state` set.
         * @param accessible a `GtkAccessible`
         * @param state a `GtkAccessibleState`
         * @returns %TRUE if the @state is set in the @accessible
         */
        function test_accessible_has_state(accessible: Accessible, state: AccessibleState | null): boolean;
        /**
         * Return the type ids that have been registered after
         * calling gtk_test_register_all_types().
         * @returns 0-terminated array of type ids
         */
        function test_list_all_types(): GObject.GType[];
        /**
         * Force registration of all core GTK object types.
         *
         * This allows to refer to any of those object types via
         * g_type_from_name() after calling this function.
         */
        function test_register_all_types(): void;
        /**
         * Enters the main loop and waits for `widget` to be “drawn”.
         *
         * In this context that means it waits for the frame clock of
         * `widget` to have run a full styling, layout and drawing cycle.
         *
         * This function is intended to be used for syncing with actions that
         * depend on `widget` relayouting or on interaction with the display
         * server.
         * @param widget the widget to wait for
         */
        function test_widget_wait_for_draw(widget: Widget): void;
        /**
         * Creates a content provider for dragging `path` from `tree_model`.
         * @param tree_model a `GtkTreeModel`
         * @param path a row in @tree_model
         * @returns a new `GdkContentProvider`
         */
        function tree_create_row_drag_content(tree_model: TreeModel, path: TreePath): Gdk.ContentProvider;
        /**
         * Obtains a `tree_model` and `path` from value of target type
         * %GTK_TYPE_TREE_ROW_DATA.
         *
         * The returned path must be freed with gtk_tree_path_free().
         * @param value a `GValue`
         * @returns %TRUE if @selection_data had target type %GTK_TYPE_TREE_ROW_DATA  is otherwise valid
         */
        function tree_get_row_drag_data(value: GObject.Value | any): [boolean, TreeModel | null, TreePath | null];
        /**
         * Lets a set of row reference created by
         * gtk_tree_row_reference_new_proxy() know that the
         * model emitted the ::row-deleted signal.
         * @param proxy a `GObject`
         * @param path the path position that was deleted
         */
        function tree_row_reference_deleted(proxy: GObject.Object, path: TreePath): void;
        /**
         * Lets a set of row reference created by
         * gtk_tree_row_reference_new_proxy() know that the
         * model emitted the ::row-inserted signal.
         * @param proxy a `GObject`
         * @param path the row position that was inserted
         */
        function tree_row_reference_inserted(proxy: GObject.Object, path: TreePath): void;
        /**
         * Retrieves the `GtkExpression` stored inside the given `value`, and acquires
         * a reference to it.
         * @param value a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
         * @returns a `GtkExpression`
         */
        function value_dup_expression(value: GObject.Value | any): Expression | null;
        /**
         * Retrieves the `GtkExpression` stored inside the given `value`.
         * @param value a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
         * @returns a `GtkExpression`
         */
        function value_get_expression(value: GObject.Value | any): Expression | null;
        /**
         * Stores the given `GtkExpression` inside `value`.
         *
         * The `GValue` will acquire a reference to the `expression`.
         * @param value a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
         * @param expression a `GtkExpression`
         */
        function value_set_expression(value: GObject.Value | any, expression: Expression): void;
        /**
         * Stores the given `GtkExpression` inside `value`.
         *
         * This function transfers the ownership of the `expression` to the `GValue`.
         * @param value a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
         * @param expression a `GtkExpression`
         */
        function value_take_expression(value: GObject.Value | any, expression?: Expression | null): void;
        interface AssistantPageFunc {
            (current_page: number): number;
        }
        interface CellAllocCallback {
            (renderer: CellRenderer, cell_area: Gdk.Rectangle, cell_background: Gdk.Rectangle): boolean;
        }
        interface CellCallback {
            (renderer: CellRenderer): boolean;
        }
        interface CellLayoutDataFunc {
            (cell_layout: CellLayout, cell: CellRenderer, tree_model: TreeModel, iter: TreeIter): void;
        }
        interface CustomAllocateFunc {
            (widget: Widget, width: number, height: number, baseline: number): void;
        }
        interface CustomFilterFunc<A = GObject.Object> {
            (item: A): boolean;
        }
        interface CustomMeasureFunc {
            (widget: Widget, orientation: Orientation, for_size: number): void;
        }
        interface CustomRequestModeFunc {
            (widget: Widget): SizeRequestMode;
        }
        interface DrawingAreaDrawFunc {
            (drawing_area: DrawingArea, cr: cairo.Context, width: number, height: number): void;
        }
        interface EntryCompletionMatchFunc {
            (completion: EntryCompletion, key: string, iter: TreeIter): boolean;
        }
        interface ExpressionNotify {
            (): void;
        }
        interface FlowBoxCreateWidgetFunc<A = GObject.Object> {
            (item: A): Widget;
        }
        interface FlowBoxFilterFunc {
            (child: FlowBoxChild): boolean;
        }
        interface FlowBoxForeachFunc {
            (box: FlowBox, child: FlowBoxChild): void;
        }
        interface FlowBoxSortFunc {
            (child1: FlowBoxChild, child2: FlowBoxChild): number;
        }
        interface FontFilterFunc {
            (family: Pango.FontFamily, face: Pango.FontFace): boolean;
        }
        interface IconViewForeachFunc {
            (icon_view: IconView, path: TreePath): void;
        }
        interface ListBoxCreateWidgetFunc<A = GObject.Object> {
            (item: A): Widget;
        }
        interface ListBoxFilterFunc {
            (row: ListBoxRow): boolean;
        }
        interface ListBoxForeachFunc {
            (box: ListBox, row: ListBoxRow): void;
        }
        interface ListBoxSortFunc {
            (row1: ListBoxRow, row2: ListBoxRow): number;
        }
        interface ListBoxUpdateHeaderFunc {
            (row: ListBoxRow, before?: ListBoxRow | null): void;
        }
        interface MapListModelMapFunc<A = GObject.Object> {
            (item: A): GObject.Object;
        }
        interface MenuButtonCreatePopupFunc {
            (menu_button: MenuButton): void;
        }
        interface PageSetupDoneFunc {
            (page_setup: PageSetup): void;
        }
        interface PrintJobCompleteFunc {
            (print_job: PrintJob, error: GLib.Error): void;
        }
        interface PrintSettingsFunc {
            (key: string, value: string): void;
        }
        interface PrinterFunc {
            (printer: Printer): boolean;
        }
        interface ScaleFormatValueFunc {
            (scale: Scale, value: number): string;
        }
        interface ShortcutFunc {
            (widget: Widget, args?: GLib.Variant | null): boolean;
        }
        interface TextBufferCommitNotify {
            (buffer: TextBuffer, flags: TextBufferNotifyFlags, position: number, length: number): void;
        }
        interface TextCharPredicate {
            (ch: number): boolean;
        }
        interface TextTagTableForeach {
            (tag: TextTag): void;
        }
        interface TickCallback {
            (widget: Widget, frame_clock: Gdk.FrameClock): boolean;
        }
        interface TreeCellDataFunc {
            (tree_column: TreeViewColumn, cell: CellRenderer, tree_model: TreeModel, iter: TreeIter): void;
        }
        interface TreeIterCompareFunc {
            (model: TreeModel, a: TreeIter, b: TreeIter): number;
        }
        interface TreeListModelCreateModelFunc<A = GObject.Object> {
            (item: A): Gio.ListModel | null;
        }
        interface TreeModelFilterModifyFunc {
            (model: TreeModel, iter: TreeIter, column: number): void;
        }
        interface TreeModelFilterVisibleFunc {
            (model: TreeModel, iter: TreeIter): boolean;
        }
        interface TreeModelForeachFunc {
            (model: TreeModel, path: TreePath, iter: TreeIter): boolean;
        }
        interface TreeSelectionForeachFunc {
            (model: TreeModel, path: TreePath, iter: TreeIter): void;
        }
        interface TreeSelectionFunc {
            (selection: TreeSelection, model: TreeModel, path: TreePath, path_currently_selected: boolean): boolean;
        }
        interface TreeViewColumnDropFunc {
            (
                tree_view: TreeView,
                column: TreeViewColumn,
                prev_column: TreeViewColumn,
                next_column: TreeViewColumn,
            ): boolean;
        }
        interface TreeViewMappingFunc {
            (tree_view: TreeView, path: TreePath): void;
        }
        interface TreeViewRowSeparatorFunc {
            (model: TreeModel, iter: TreeIter): boolean;
        }
        interface TreeViewSearchEqualFunc {
            (model: TreeModel, column: number, key: string, iter: TreeIter): boolean;
        }
        interface WidgetActionActivateFunc {
            (widget: Widget, action_name: string, parameter?: GLib.Variant | null): void;
        }
        type TreeRowData = object | null;
        /**
         * Types of user actions that may be blocked by `GtkApplication`.
         *
         * See [method`Gtk`.Application.inhibit].
         */

        /**
         * Types of user actions that may be blocked by `GtkApplication`.
         *
         * See [method`Gtk`.Application.inhibit].
         */
        export namespace ApplicationInhibitFlags {
            export const $gtype: GObject.GType<ApplicationInhibitFlags>;
        }

        enum ApplicationInhibitFlags {
            /**
             * Inhibit ending the user session
             *   by logging out or by shutting down the computer
             */
            LOGOUT,
            /**
             * Inhibit user switching
             */
            SWITCH,
            /**
             * Inhibit suspending the
             *   session or computer
             */
            SUSPEND,
            /**
             * Inhibit the session being
             *   marked as idle (and possibly locked)
             */
            IDLE,
        }
        /**
         * The list of flags that can be passed to gtk_builder_create_closure().
         *
         * New values may be added in the future for new features, so external
         * implementations of [iface`Gtk`.BuilderScope] should test the flags
         * for unknown values and raise a %GTK_BUILDER_ERROR_INVALID_ATTRIBUTE error
         * when they encounter one.
         */

        /**
         * The list of flags that can be passed to gtk_builder_create_closure().
         *
         * New values may be added in the future for new features, so external
         * implementations of [iface`Gtk`.BuilderScope] should test the flags
         * for unknown values and raise a %GTK_BUILDER_ERROR_INVALID_ATTRIBUTE error
         * when they encounter one.
         */
        export namespace BuilderClosureFlags {
            export const $gtype: GObject.GType<BuilderClosureFlags>;
        }

        enum BuilderClosureFlags {
            /**
             * The closure should be created swapped. See
             *   g_cclosure_new_swap() for details.
             */
            SWAPPED,
        }
        /**
         * Tells how a cell is to be rendered.
         */

        /**
         * Tells how a cell is to be rendered.
         */
        export namespace CellRendererState {
            export const $gtype: GObject.GType<CellRendererState>;
        }

        enum CellRendererState {
            /**
             * The cell is currently selected, and
             *  probably has a selection colored background to render to.
             */
            SELECTED,
            /**
             * The mouse is hovering over the cell.
             */
            PRELIT,
            /**
             * The cell is drawn in an insensitive manner
             */
            INSENSITIVE,
            /**
             * The cell is in a sorted row
             */
            SORTED,
            /**
             * The cell is in the focus row.
             */
            FOCUSED,
            /**
             * The cell is in a row that can be expanded
             */
            EXPANDABLE,
            /**
             * The cell is in a row that is expanded
             */
            EXPANDED,
        }
        /**
         * Flags to use with gtk_set_debug_flags().
         *
         * Settings these flags causes GTK to print out different
         * types of debugging information. Some of these flags are
         * only available when GTK has been configured with `-Ddebug=true`.
         */

        /**
         * Flags to use with gtk_set_debug_flags().
         *
         * Settings these flags causes GTK to print out different
         * types of debugging information. Some of these flags are
         * only available when GTK has been configured with `-Ddebug=true`.
         */
        export namespace DebugFlags {
            export const $gtype: GObject.GType<DebugFlags>;
        }

        enum DebugFlags {
            /**
             * Information about GtkTextView
             */
            TEXT,
            /**
             * Information about GtkTreeView
             */
            TREE,
            /**
             * Information about keyboard shortcuts
             */
            KEYBINDINGS,
            /**
             * Information about modules and extensions
             */
            MODULES,
            /**
             * Information about size allocation
             */
            GEOMETRY,
            /**
             * Information about icon themes
             */
            ICONTHEME,
            /**
             * Information about printing
             */
            PRINTING,
            /**
             * Trace GtkBuilder operation
             */
            BUILDER,
            /**
             * Information about size requests
             */
            SIZE_REQUEST,
            /**
             * Disable the style property cache
             */
            NO_CSS_CACHE,
            /**
             * Open the GTK inspector
             */
            INTERACTIVE,
            /**
             * Information about actions and menu models
             */
            ACTIONS,
            /**
             * Information from layout managers
             */
            LAYOUT,
            /**
             * Include debug render nodes in the generated snapshots
             */
            SNAPSHOT,
            /**
             * Information from the constraints solver
             */
            CONSTRAINTS,
            /**
             * Log unused GtkBuilder objects
             */
            BUILDER_OBJECTS,
            /**
             * Information about accessibility state changes
             */
            A11Y,
            /**
             * Information about icon fallback.
             */
            ICONFALLBACK,
            /**
             * Inverts the default text-direction.
             */
            INVERT_TEXT_DIR,
            /**
             * Information about deprecated CSS features.
             */
            CSS,
        }
        /**
         * Flags used to influence dialog construction.
         */

        /**
         * Flags used to influence dialog construction.
         */
        export namespace DialogFlags {
            export const $gtype: GObject.GType<DialogFlags>;
        }

        enum DialogFlags {
            /**
             * Make the constructed dialog modal
             */
            MODAL,
            /**
             * Destroy the dialog when its parent is destroyed
             */
            DESTROY_WITH_PARENT,
            /**
             * Create dialog with actions in header
             *   bar instead of action area
             */
            USE_HEADER_BAR,
        }
        /**
         * Describes the behavior of a `GtkEventControllerScroll`.
         */

        /**
         * Describes the behavior of a `GtkEventControllerScroll`.
         */
        export namespace EventControllerScrollFlags {
            export const $gtype: GObject.GType<EventControllerScrollFlags>;
        }

        enum EventControllerScrollFlags {
            /**
             * Don't emit scroll.
             */
            NONE,
            /**
             * Emit scroll with vertical deltas.
             */
            VERTICAL,
            /**
             * Emit scroll with horizontal deltas.
             */
            HORIZONTAL,
            /**
             * Only emit deltas that are multiples of 1.
             */
            DISCRETE,
            /**
             * Emit ::decelerate after continuous scroll finishes.
             */
            KINETIC,
            /**
             * Emit scroll on both axes.
             */
            BOTH_AXES,
        }
        /**
         * Specifies the granularity of font selection
         * that is desired in a `GtkFontChooser`.
         *
         * This enumeration may be extended in the future; applications should
         * ignore unknown values.
         */

        /**
         * Specifies the granularity of font selection
         * that is desired in a `GtkFontChooser`.
         *
         * This enumeration may be extended in the future; applications should
         * ignore unknown values.
         */
        export namespace FontChooserLevel {
            export const $gtype: GObject.GType<FontChooserLevel>;
        }

        enum FontChooserLevel {
            /**
             * Allow selecting a font family
             */
            FAMILY,
            /**
             * Allow selecting a specific font face
             */
            STYLE,
            /**
             * Allow selecting a specific font size
             */
            SIZE,
            /**
             * Allow changing OpenType font variation axes
             */
            VARIATIONS,
            /**
             * Allow selecting specific OpenType font features
             */
            FEATURES,
        }
        /**
         * Used to specify options for gtk_icon_theme_lookup_icon().
         */

        /**
         * Used to specify options for gtk_icon_theme_lookup_icon().
         */
        export namespace IconLookupFlags {
            export const $gtype: GObject.GType<IconLookupFlags>;
        }

        enum IconLookupFlags {
            /**
             * Try to always load regular icons, even
             *   when symbolic icon names are given
             */
            FORCE_REGULAR,
            /**
             * Try to always load symbolic icons, even
             *   when regular icon names are given
             */
            FORCE_SYMBOLIC,
            /**
             * Starts loading the texture in the background
             *   so it is ready when later needed.
             */
            PRELOAD,
        }
        /**
         * Describes hints that might be taken into account by input methods
         * or applications.
         *
         * Note that input methods may already tailor their behaviour according
         * to the [enum`InputPurpose]` of the entry.
         *
         * Some common sense is expected when using these flags - mixing
         * %GTK_INPUT_HINT_LOWERCASE with any of the uppercase hints makes no sense.
         *
         * This enumeration may be extended in the future; input methods should
         * ignore unknown values.
         */

        /**
         * Describes hints that might be taken into account by input methods
         * or applications.
         *
         * Note that input methods may already tailor their behaviour according
         * to the [enum`InputPurpose]` of the entry.
         *
         * Some common sense is expected when using these flags - mixing
         * %GTK_INPUT_HINT_LOWERCASE with any of the uppercase hints makes no sense.
         *
         * This enumeration may be extended in the future; input methods should
         * ignore unknown values.
         */
        export namespace InputHints {
            export const $gtype: GObject.GType<InputHints>;
        }

        enum InputHints {
            /**
             * No special behaviour suggested
             */
            NONE,
            /**
             * Suggest checking for typos
             */
            SPELLCHECK,
            /**
             * Suggest not checking for typos
             */
            NO_SPELLCHECK,
            /**
             * Suggest word completion
             */
            WORD_COMPLETION,
            /**
             * Suggest to convert all text to lowercase
             */
            LOWERCASE,
            /**
             * Suggest to capitalize all text
             */
            UPPERCASE_CHARS,
            /**
             * Suggest to capitalize the first
             *   character of each word
             */
            UPPERCASE_WORDS,
            /**
             * Suggest to capitalize the
             *   first word of each sentence
             */
            UPPERCASE_SENTENCES,
            /**
             * Suggest to not show an onscreen keyboard
             *   (e.g for a calculator that already has all the keys).
             */
            INHIBIT_OSK,
            /**
             * The text is vertical
             */
            VERTICAL_WRITING,
            /**
             * Suggest offering Emoji support
             */
            EMOJI,
            /**
             * Suggest not offering Emoji support
             */
            NO_EMOJI,
            /**
             * Request that the input method should not
             *    update personalized data (like typing history)
             */
            PRIVATE,
        }
        /**
         * List of actions to perform when scrolling to items in
         * a list widget.
         */

        /**
         * List of actions to perform when scrolling to items in
         * a list widget.
         */
        export namespace ListScrollFlags {
            export const $gtype: GObject.GType<ListScrollFlags>;
        }

        enum ListScrollFlags {
            /**
             * Don't do anything extra
             */
            NONE,
            /**
             * Focus the target item
             */
            FOCUS,
            /**
             * Select the target item and
             *   unselect all other items.
             */
            SELECT,
        }
        /**
         * Flags that influence the behavior of [method`Widget`.pick].
         */

        /**
         * Flags that influence the behavior of [method`Widget`.pick].
         */
        export namespace PickFlags {
            export const $gtype: GObject.GType<PickFlags>;
        }

        enum PickFlags {
            /**
             * The default behavior, include widgets that are receiving events
             */
            DEFAULT,
            /**
             * Include widgets that are insensitive
             */
            INSENSITIVE,
            /**
             * Include widgets that are marked as non-targetable. See [property`Widget:`can-target]
             */
            NON_TARGETABLE,
        }
        /**
         * Flags that affect how [class`Gtk`.PopoverMenu] widgets built from
         * a [class`Gio`.MenuModel] are created and displayed.
         */

        /**
         * Flags that affect how [class`Gtk`.PopoverMenu] widgets built from
         * a [class`Gio`.MenuModel] are created and displayed.
         */
        export namespace PopoverMenuFlags {
            export const $gtype: GObject.GType<PopoverMenuFlags>;
        }

        enum PopoverMenuFlags {
            /**
             * Submenus are presented as sliding submenus that replace the main menu.
             */
            SLIDING,
            /**
             * Submenus are presented as traditional, nested
             *   popovers.
             */
            NESTED,
        }
        /**
         * Specifies which features the print dialog should offer.
         *
         * If neither %GTK_PRINT_CAPABILITY_GENERATE_PDF nor
         * %GTK_PRINT_CAPABILITY_GENERATE_PS is specified, GTK assumes that all
         * formats are supported.
         */

        /**
         * Specifies which features the print dialog should offer.
         *
         * If neither %GTK_PRINT_CAPABILITY_GENERATE_PDF nor
         * %GTK_PRINT_CAPABILITY_GENERATE_PS is specified, GTK assumes that all
         * formats are supported.
         */
        export namespace PrintCapabilities {
            export const $gtype: GObject.GType<PrintCapabilities>;
        }

        enum PrintCapabilities {
            /**
             * Print dialog will offer printing even/odd pages.
             */
            PAGE_SET,
            /**
             * Print dialog will allow to print multiple copies.
             */
            COPIES,
            /**
             * Print dialog will allow to collate multiple copies.
             */
            COLLATE,
            /**
             * Print dialog will allow to print pages in reverse order.
             */
            REVERSE,
            /**
             * Print dialog will allow to scale the output.
             */
            SCALE,
            /**
             * The program will send the document to
             *   the printer in PDF format
             */
            GENERATE_PDF,
            /**
             * The program will send the document to
             *   the printer in Postscript format
             */
            GENERATE_PS,
            /**
             * Print dialog will offer a preview
             */
            PREVIEW,
            /**
             * Print dialog will offer printing multiple
             *   pages per sheet
             */
            NUMBER_UP,
            /**
             * Print dialog will allow to rearrange
             *   pages when printing multiple pages per sheet
             */
            NUMBER_UP_LAYOUT,
        }
        /**
         * List of flags that can be passed to action activation.
         *
         * More flags may be added in the future.
         */

        /**
         * List of flags that can be passed to action activation.
         *
         * More flags may be added in the future.
         */
        export namespace ShortcutActionFlags {
            export const $gtype: GObject.GType<ShortcutActionFlags>;
        }

        enum ShortcutActionFlags {
            /**
             * The action is the only
             *   action that can be activated. If this flag is not set,
             *   a future activation may select a different action.
             */
            EXCLUSIVE,
        }
        /**
         * Describes a widget state.
         *
         * Widget states are used to match the widget against CSS pseudo-classes.
         * Note that GTK extends the regular CSS classes and sometimes uses
         * different names.
         */

        /**
         * Describes a widget state.
         *
         * Widget states are used to match the widget against CSS pseudo-classes.
         * Note that GTK extends the regular CSS classes and sometimes uses
         * different names.
         */
        export namespace StateFlags {
            export const $gtype: GObject.GType<StateFlags>;
        }

        enum StateFlags {
            /**
             * State during normal operation
             */
            NORMAL,
            /**
             * Widget is active
             */
            ACTIVE,
            /**
             * Widget has a mouse pointer over it
             */
            PRELIGHT,
            /**
             * Widget is selected
             */
            SELECTED,
            /**
             * Widget is insensitive
             */
            INSENSITIVE,
            /**
             * Widget is inconsistent
             */
            INCONSISTENT,
            /**
             * Widget has the keyboard focus
             */
            FOCUSED,
            /**
             * Widget is in a background toplevel window
             */
            BACKDROP,
            /**
             * Widget is in left-to-right text direction
             */
            DIR_LTR,
            /**
             * Widget is in right-to-left text direction
             */
            DIR_RTL,
            /**
             * Widget is a link
             */
            LINK,
            /**
             * The location the widget points to has already been visited
             */
            VISITED,
            /**
             * Widget is checked
             */
            CHECKED,
            /**
             * Widget is highlighted as a drop target for DND
             */
            DROP_ACTIVE,
            /**
             * Widget has the visible focus
             */
            FOCUS_VISIBLE,
            /**
             * Widget contains the keyboard focus
             */
            FOCUS_WITHIN,
        }
        /**
         * Flags that modify the behavior of gtk_style_context_to_string().
         *
         * New values may be added to this enumeration.
         */

        /**
         * Flags that modify the behavior of gtk_style_context_to_string().
         *
         * New values may be added to this enumeration.
         */
        export namespace StyleContextPrintFlags {
            export const $gtype: GObject.GType<StyleContextPrintFlags>;
        }

        enum StyleContextPrintFlags {
            /**
             * Default value.
             */
            NONE,
            /**
             * Print the entire tree of
             *   CSS nodes starting at the style context's node
             */
            RECURSE,
            /**
             * Show the values of the
             *   CSS properties for each node
             */
            SHOW_STYLE,
            /**
             * Show information about
             *   what changes affect the styles
             */
            SHOW_CHANGE,
        }
        /**
         * Values for [callback`Gtk`.TextBufferCommitNotify] to denote the
         * point of the notification.
         */

        /**
         * Values for [callback`Gtk`.TextBufferCommitNotify] to denote the
         * point of the notification.
         */
        export namespace TextBufferNotifyFlags {
            export const $gtype: GObject.GType<TextBufferNotifyFlags>;
        }

        enum TextBufferNotifyFlags {
            /**
             * Be notified before text
             *   is inserted into the underlying buffer.
             */
            BEFORE_INSERT,
            /**
             * Be notified after text
             *   has been inserted into the underlying buffer.
             */
            AFTER_INSERT,
            /**
             * Be notified before text
             *   is deleted from the underlying buffer.
             */
            BEFORE_DELETE,
            /**
             * Be notified after text
             *   has been deleted from the underlying buffer.
             */
            AFTER_DELETE,
        }
        /**
         * Flags affecting how a search is done.
         *
         * If neither %GTK_TEXT_SEARCH_VISIBLE_ONLY nor %GTK_TEXT_SEARCH_TEXT_ONLY are
         * enabled, the match must be exact; the special 0xFFFC character will match
         * embedded paintables or child widgets.
         */

        /**
         * Flags affecting how a search is done.
         *
         * If neither %GTK_TEXT_SEARCH_VISIBLE_ONLY nor %GTK_TEXT_SEARCH_TEXT_ONLY are
         * enabled, the match must be exact; the special 0xFFFC character will match
         * embedded paintables or child widgets.
         */
        export namespace TextSearchFlags {
            export const $gtype: GObject.GType<TextSearchFlags>;
        }

        enum TextSearchFlags {
            /**
             * Search only visible data. A search match may
             * have invisible text interspersed.
             */
            VISIBLE_ONLY,
            /**
             * Search only text. A match may have paintables or
             * child widgets mixed inside the matched range.
             */
            TEXT_ONLY,
            /**
             * The text will be matched regardless of
             * what case it is in.
             */
            CASE_INSENSITIVE,
        }
        /**
         * These flags indicate various properties of a `GtkTreeModel`.
         *
         * They are returned by [method`Gtk`.TreeModel.get_flags], and must be
         * static for the lifetime of the object. A more complete description
         * of %GTK_TREE_MODEL_ITERS_PERSIST can be found in the overview of
         * this section.
         */

        /**
         * These flags indicate various properties of a `GtkTreeModel`.
         *
         * They are returned by [method`Gtk`.TreeModel.get_flags], and must be
         * static for the lifetime of the object. A more complete description
         * of %GTK_TREE_MODEL_ITERS_PERSIST can be found in the overview of
         * this section.
         */
        export namespace TreeModelFlags {
            export const $gtype: GObject.GType<TreeModelFlags>;
        }

        enum TreeModelFlags {
            /**
             * iterators survive all signals
             *   emitted by the tree
             */
            ITERS_PERSIST,
            /**
             * the model is a list only, and never
             *   has children
             */
            LIST_ONLY,
        }
        namespace ATContext {
            // Signal callback interfaces

            interface StateChange {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                accessible: Accessible;
                accessible_role: AccessibleRole;
                accessibleRole: AccessibleRole;
                display: Gdk.Display;
            }
        }

        /**
         * `GtkATContext` is an abstract class provided by GTK to communicate to
         * platform-specific assistive technologies API.
         *
         * Each platform supported by GTK implements a `GtkATContext` subclass, and
         * is responsible for updating the accessible state in response to state
         * changes in `GtkAccessible`.
         */
        abstract class ATContext extends GObject.Object {
            static $gtype: GObject.GType<ATContext>;

            // Properties

            /**
             * The `GtkAccessible` that created the `GtkATContext` instance.
             */
            get accessible(): Accessible;
            /**
             * The accessible role used by the AT context.
             *
             * Depending on the given role, different states and properties can be
             * set or retrieved.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role used by the AT context.
             *
             * Depending on the given role, different states and properties can be
             * set or retrieved.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The `GdkDisplay` for the `GtkATContext`.
             */
            get display(): Gdk.Display;
            set display(val: Gdk.Display);

            // Constructors

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

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

            static create(accessible_role: AccessibleRole, accessible: Accessible, display: Gdk.Display): ATContext;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'state-change', callback: (_source: this) => void): number;
            connect_after(signal: 'state-change', callback: (_source: this) => void): number;
            emit(signal: 'state-change'): void;

            // Methods

            /**
             * Retrieves the `GtkAccessible` using this context.
             * @returns a `GtkAccessible`
             */
            get_accessible(): Accessible;
            /**
             * Retrieves the accessible role of this context.
             * @returns a `GtkAccessibleRole`
             */
            get_accessible_role(): AccessibleRole;
        }

        namespace AboutDialog {
            // Signal callback interfaces

            interface ActivateLink {
                (uri: string): boolean;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Window.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Native.ConstructorProps,
                    Root.ConstructorProps,
                    ShortcutManager.ConstructorProps {
                artists: string[];
                authors: string[];
                comments: string;
                copyright: string;
                documenters: string[];
                license: string;
                license_type: License;
                licenseType: License;
                logo: Gdk.Paintable;
                logo_icon_name: string;
                logoIconName: string;
                program_name: string;
                programName: string;
                system_information: string;
                systemInformation: string;
                translator_credits: string;
                translatorCredits: string;
                version: string;
                website: string;
                website_label: string;
                websiteLabel: string;
                wrap_license: boolean;
                wrapLicense: boolean;
            }
        }

        /**
         * The `GtkAboutDialog` offers a simple way to display information about
         * a program.
         *
         * The shown information includes the programs' logo, name, copyright,
         * website and license. It is also possible to give credits to the authors,
         * documenters, translators and artists who have worked on the program.
         *
         * An about dialog is typically opened when the user selects the `About`
         * option from the `Help` menu. All parts of the dialog are optional.
         *
         * ![An example GtkAboutDialog](aboutdialog.png)
         *
         * About dialogs often contain links and email addresses. `GtkAboutDialog`
         * displays these as clickable links. By default, it calls [method`Gtk`.FileLauncher.launch]
         * when a user clicks one. The behaviour can be overridden with the
         * [signal`Gtk`.AboutDialog::activate-link] signal.
         *
         * To specify a person with an email address, use a string like
         * `Edgar Allan Poe <edgar`poe`.com>`. To specify a website with a title,
         * use a string like `GTK team https://www.gtk.org`.
         *
         * To make constructing a `GtkAboutDialog` as convenient as possible, you can
         * use the function [func`Gtk`.show_about_dialog] which constructs and shows
         * a dialog and keeps it around so that it can be shown again.
         *
         * Note that GTK sets a default title of `_("About %s")` on the dialog
         * window (where `%s` is replaced by the name of the application, but in
         * order to ensure proper translation of the title, applications should
         * set the title property explicitly when constructing a `GtkAboutDialog`,
         * as shown in the following example:
         *
         * ```c
         * GFile *logo_file = g_file_new_for_path ("./logo.png");
         * GdkTexture *example_logo = gdk_texture_new_from_file (logo_file, NULL);
         * g_object_unref (logo_file);
         *
         * gtk_show_about_dialog (NULL,
         *                        "program-name", "ExampleCode",
         *                        "logo", example_logo,
         *                        "title", _("About ExampleCode"),
         *                        NULL);
         * ```
         *
         * ## Shortcuts and Gestures
         *
         * `GtkAboutDialog` supports the following keyboard shortcuts:
         *
         * - <kbd>Escape</kbd> closes the window.
         *
         * ## CSS nodes
         *
         * `GtkAboutDialog` has a single CSS node with the name `window` and style
         * class `.aboutdialog`.
         */
        class AboutDialog
            extends Window
            implements Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager
        {
            static $gtype: GObject.GType<AboutDialog>;

            // Properties

            /**
             * The people who contributed artwork to the program, as a `NULL`-terminated
             * array of strings.
             *
             * Each string may contain email addresses and URLs, which will be displayed
             * as links.
             */
            get artists(): string[];
            set artists(val: string[]);
            /**
             * The authors of the program, as a `NULL`-terminated array of strings.
             *
             * Each string may contain email addresses and URLs, which will be displayed
             * as links, see the introduction for more details.
             */
            get authors(): string[];
            set authors(val: string[]);
            /**
             * Comments about the program.
             *
             * This string is displayed in a label in the main dialog, thus it
             * should be a short explanation of the main purpose of the program,
             * not a detailed list of features.
             */
            get comments(): string;
            set comments(val: string);
            /**
             * Copyright information for the program.
             */
            get copyright(): string;
            set copyright(val: string);
            /**
             * The people documenting the program, as a `NULL`-terminated array of strings.
             *
             * Each string may contain email addresses and URLs, which will be displayed
             * as links, see the introduction for more details.
             */
            get documenters(): string[];
            set documenters(val: string[]);
            /**
             * The license of the program, as free-form text.
             *
             * This string is displayed in a text view in a secondary dialog, therefore
             * it is fine to use a long multi-paragraph text. Note that the text is only
             * wrapped in the text view if the "wrap-license" property is set to `TRUE`;
             * otherwise the text itself must contain the intended linebreaks.
             *
             * When setting this property to a non-`NULL` value, the
             * [property`Gtk`.AboutDialog:license-type] property is set to
             * `GTK_LICENSE_CUSTOM` as a side effect.
             *
             * The text may contain links in this format `<http://www.some.place/>`
             * and email references in the form `<mail-to`some`.body>`, and these will
             * be converted into clickable links.
             */
            get license(): string;
            set license(val: string);
            /**
             * The license of the program.
             *
             * The `GtkAboutDialog` will automatically fill out a standard disclaimer
             * and link the user to the appropriate online resource for the license
             * text.
             *
             * If `GTK_LICENSE_UNKNOWN` is used, the link used will be the same
             * specified in the [property`Gtk`.AboutDialog:website] property.
             *
             * If `GTK_LICENSE_CUSTOM` is used, the current contents of the
             * [property`Gtk`.AboutDialog:license] property are used.
             *
             * For any other [enum`Gtk`.License] value, the contents of the
             * [property`Gtk`.AboutDialog:license] property are also set by this property as
             * a side effect.
             */
            get license_type(): License;
            set license_type(val: License);
            /**
             * The license of the program.
             *
             * The `GtkAboutDialog` will automatically fill out a standard disclaimer
             * and link the user to the appropriate online resource for the license
             * text.
             *
             * If `GTK_LICENSE_UNKNOWN` is used, the link used will be the same
             * specified in the [property`Gtk`.AboutDialog:website] property.
             *
             * If `GTK_LICENSE_CUSTOM` is used, the current contents of the
             * [property`Gtk`.AboutDialog:license] property are used.
             *
             * For any other [enum`Gtk`.License] value, the contents of the
             * [property`Gtk`.AboutDialog:license] property are also set by this property as
             * a side effect.
             */
            get licenseType(): License;
            set licenseType(val: License);
            /**
             * A logo for the about box.
             *
             * If it is `NULL`, the default window icon set with
             * [func`Gtk`.Window.set_default_icon_name] will be used.
             */
            get logo(): Gdk.Paintable;
            set logo(val: Gdk.Paintable);
            /**
             * A named icon to use as the logo for the about box.
             *
             * This property overrides the [property`Gtk`.AboutDialog:logo] property.
             */
            get logo_icon_name(): string;
            set logo_icon_name(val: string);
            /**
             * A named icon to use as the logo for the about box.
             *
             * This property overrides the [property`Gtk`.AboutDialog:logo] property.
             */
            get logoIconName(): string;
            set logoIconName(val: string);
            /**
             * The name of the program.
             *
             * If this is not set, it defaults to the value returned by
             * `g_get_application_name()`.
             */
            get program_name(): string;
            set program_name(val: string);
            /**
             * The name of the program.
             *
             * If this is not set, it defaults to the value returned by
             * `g_get_application_name()`.
             */
            get programName(): string;
            set programName(val: string);
            /**
             * Information about the system on which the program is running.
             *
             * This information is displayed in a separate page, therefore it is fine
             * to use a long multi-paragraph text. Note that the text should contain
             * the intended linebreaks.
             *
             * The text may contain links in this format `<http://www.some.place/>`
             * and email references in the form `<mail-to`some`.body>`, and these will
             * be converted into clickable links.
             */
            get system_information(): string;
            set system_information(val: string);
            /**
             * Information about the system on which the program is running.
             *
             * This information is displayed in a separate page, therefore it is fine
             * to use a long multi-paragraph text. Note that the text should contain
             * the intended linebreaks.
             *
             * The text may contain links in this format `<http://www.some.place/>`
             * and email references in the form `<mail-to`some`.body>`, and these will
             * be converted into clickable links.
             */
            get systemInformation(): string;
            set systemInformation(val: string);
            /**
             * Credits to the translators.
             *
             * This string should be marked as translatable.
             *
             * The string may contain email addresses and URLs, which will be displayed
             * as links, see the introduction for more details.
             */
            get translator_credits(): string;
            set translator_credits(val: string);
            /**
             * Credits to the translators.
             *
             * This string should be marked as translatable.
             *
             * The string may contain email addresses and URLs, which will be displayed
             * as links, see the introduction for more details.
             */
            get translatorCredits(): string;
            set translatorCredits(val: string);
            /**
             * The version of the program.
             */
            get version(): string;
            set version(val: string);
            /**
             * The URL for the link to the website of the program.
             *
             * This should be a string starting with `http://` or `https://`.
             */
            get website(): string;
            set website(val: string);
            /**
             * The label for the link to the website of the program.
             */
            get website_label(): string;
            set website_label(val: string);
            /**
             * The label for the link to the website of the program.
             */
            get websiteLabel(): string;
            set websiteLabel(val: string);
            /**
             * Whether to wrap the text in the license dialog.
             */
            get wrap_license(): boolean;
            set wrap_license(val: boolean);
            /**
             * Whether to wrap the text in the license dialog.
             */
            get wrapLicense(): boolean;
            set wrapLicense(val: boolean);

            // Constructors

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

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

            static ['new'](): AboutDialog;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate-link', callback: (_source: this, uri: string) => boolean): number;
            connect_after(signal: 'activate-link', callback: (_source: this, uri: string) => boolean): number;
            emit(signal: 'activate-link', uri: string): void;

            // Methods

            /**
             * Creates a new section in the "Credits" page.
             * @param section_name The name of the section
             * @param people The people who belong to that section
             */
            add_credit_section(section_name: string, people: string[]): void;
            /**
             * Returns the names of the artists which are displayed
             * in the credits page.
             * @returns A   `NULL`-terminated string array containing the artists
             */
            get_artists(): string[];
            /**
             * Returns the names of the authors which are displayed
             * in the credits page.
             * @returns A   `NULL`-terminated string array containing the authors
             */
            get_authors(): string[];
            /**
             * Returns the comments string.
             * @returns The comments
             */
            get_comments(): string | null;
            /**
             * Returns the copyright string.
             * @returns The copyright string
             */
            get_copyright(): string | null;
            /**
             * Returns the name of the documenters which are displayed
             * in the credits page.
             * @returns A   `NULL`-terminated string array containing the documenters
             */
            get_documenters(): string[];
            /**
             * Returns the license information.
             * @returns The license information
             */
            get_license(): string | null;
            /**
             * Retrieves the license type.
             * @returns a [enum@Gtk.License] value
             */
            get_license_type(): License;
            /**
             * Returns the paintable displayed as logo in the about dialog.
             * @returns the paintable displayed as   logo or `NULL` if the logo is unset or has been set via   [method@Gtk.AboutDialog.set_logo_icon_name]
             */
            get_logo(): Gdk.Paintable | null;
            /**
             * Returns the icon name displayed as logo in the about dialog.
             * @returns the icon name displayed as logo,   or `NULL` if the logo has been set via [method@Gtk.AboutDialog.set_logo]
             */
            get_logo_icon_name(): string | null;
            /**
             * Returns the program name displayed in the about dialog.
             * @returns The program name
             */
            get_program_name(): string | null;
            /**
             * Returns the system information that is shown in the about dialog.
             * @returns the system information
             */
            get_system_information(): string | null;
            /**
             * Returns the translator credits string which is displayed
             * in the credits page.
             * @returns The translator credits string
             */
            get_translator_credits(): string | null;
            /**
             * Returns the version string.
             * @returns The version string
             */
            get_version(): string | null;
            /**
             * Returns the website URL.
             * @returns The website URL
             */
            get_website(): string | null;
            /**
             * Returns the label used for the website link.
             * @returns The label used for the website link
             */
            get_website_label(): string | null;
            /**
             * Returns whether the license text in the about dialog is
             * automatically wrapped.
             * @returns `TRUE` if the license text is wrapped
             */
            get_wrap_license(): boolean;
            /**
             * Sets the names of the artists to be displayed
             * in the "Credits" page.
             * @param artists the authors of the artwork   of the application
             */
            set_artists(artists: string[]): void;
            /**
             * Sets the names of the authors which are displayed
             * in the "Credits" page of the about dialog.
             * @param authors the authors of the application
             */
            set_authors(authors: string[]): void;
            /**
             * Sets the comments string to display in the about dialog.
             *
             * This should be a short string of one or two lines.
             * @param comments a comments string
             */
            set_comments(comments?: string | null): void;
            /**
             * Sets the copyright string to display in the about dialog.
             *
             * This should be a short string of one or two lines.
             * @param copyright the copyright string
             */
            set_copyright(copyright?: string | null): void;
            /**
             * Sets the names of the documenters which are displayed
             * in the "Credits" page.
             * @param documenters the authors of the documentation   of the application
             */
            set_documenters(documenters: string[]): void;
            /**
             * Sets the license information to be displayed in the
             * about dialog.
             *
             * If `license` is `NULL`, the license page is hidden.
             * @param license the license information
             */
            set_license(license?: string | null): void;
            /**
             * Sets the license of the application showing the about dialog from a
             * list of known licenses.
             *
             * This function overrides the license set using
             * [method`Gtk`.AboutDialog.set_license].
             * @param license_type the type of license
             */
            set_license_type(license_type: License | null): void;
            /**
             * Sets the logo in the about dialog.
             * @param logo a `GdkPaintable`
             */
            set_logo(logo?: Gdk.Paintable | null): void;
            /**
             * Sets the icon name to be displayed as logo in the about dialog.
             * @param icon_name an icon name
             */
            set_logo_icon_name(icon_name?: string | null): void;
            /**
             * Sets the name to display in the about dialog.
             *
             * If `name` is not set, the string returned
             * by `g_get_application_name()` is used.
             * @param name the program name
             */
            set_program_name(name?: string | null): void;
            /**
             * Sets the system information to be displayed in the about
             * dialog.
             *
             * If `system_information` is `NULL`, the system information
             * page is hidden.
             *
             * See [property`Gtk`.AboutDialog:system-information].
             * @param system_information system information
             */
            set_system_information(system_information?: string | null): void;
            /**
             * Sets the translator credits string which is displayed in
             * the credits page.
             *
             * The intended use for this string is to display the translator
             * of the language which is currently used in the user interface.
             * Using `gettext()`, a simple way to achieve that is to mark the
             * string for translation:
             *
             * ```c
             * GtkWidget *about = gtk_about_dialog_new ();
             *  gtk_about_dialog_set_translator_credits (GTK_ABOUT_DIALOG (about),
             *                                           _("translator-credits"));
             * ```
             *
             * It is a good idea to use the customary `msgid` “translator-credits”
             * for this purpose, since translators will already know the purpose of
             * that `msgid`, and since `GtkAboutDialog` will detect if “translator-credits”
             * is untranslated and omit translator credits.
             * @param translator_credits the translator credits
             */
            set_translator_credits(translator_credits?: string | null): void;
            /**
             * Sets the version string to display in the about dialog.
             * @param version the version string
             */
            set_version(version?: string | null): void;
            /**
             * Sets the URL to use for the website link.
             * @param website a URL string starting with `http://`
             */
            set_website(website?: string | null): void;
            /**
             * Sets the label to be used for the website link.
             * @param website_label the label used for the website link
             */
            set_website_label(website_label: string): void;
            /**
             * Sets whether the license text in the about dialog should be
             * automatically wrapped.
             * @param wrap_license whether to wrap the license
             */
            set_wrap_license(wrap_license: boolean): void;

            // Inherited properties
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Returns the renderer that is used for this `GtkNative`.
             * @returns the renderer for @self
             */
            get_renderer(): Gsk.Renderer | null;
            /**
             * Returns the surface of this `GtkNative`.
             * @returns the surface of @self
             */
            get_surface(): Gdk.Surface | null;
            /**
             * Retrieves the surface transform of `self`.
             *
             * This is the translation from `self'`s surface coordinates into
             * `self'`s widget coordinates.
             */
            get_surface_transform(): [number, number];
            /**
             * Realizes a `GtkNative`.
             *
             * This should only be used by subclasses.
             */
            realize(): void;
            /**
             * Unrealizes a `GtkNative`.
             *
             * This should only be used by subclasses.
             */
            unrealize(): void;
            /**
             * Returns the display that this `GtkRoot` is on.
             * @returns the display of @root
             */
            get_display(): Gdk.Display;
            /**
             * Retrieves the current focused widget within the root.
             *
             * Note that this is the widget that would have the focus
             * if the root is active; if the root is not focused then
             * `gtk_widget_has_focus (widget)` will be %FALSE for the
             * widget.
             * @returns the currently focused widget
             */
            get_focus(): Widget | null;
            /**
             * If `focus` is not the current focus widget, and is focusable, sets
             * it as the focus widget for the root.
             *
             * If `focus` is %NULL, unsets the focus widget for the root.
             *
             * To set the focus to a particular widget in the root, it is usually
             * more convenient to use [method`Gtk`.Widget.grab_focus] instead of
             * this function.
             * @param focus widget to be the new focus widget, or %NULL    to unset the focus widget
             */
            set_focus(focus?: Widget | null): void;
            /**
             * Add a `GtkShortcutController` to be managed.
             * @param controller
             */
            vfunc_add_controller(controller: ShortcutController): void;
            /**
             * Remove a `GtkShortcutController` that had previously
             *   been added
             * @param controller
             */
            vfunc_remove_controller(controller: ShortcutController): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace ActionBar {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                revealed: boolean;
            }
        }

        /**
         * `GtkActionBar` is designed to present contextual actions.
         *
         * ![An example GtkActionBar](action-bar.png)
         *
         * It is expected to be displayed below the content and expand
         * horizontally to fill the area.
         *
         * It allows placing children at the start or the end. In addition, it
         * contains an internal centered box which is centered with respect to
         * the full width of the box, even if the children at either side take
         * up different amounts of space.
         *
         * # GtkActionBar as GtkBuildable
         *
         * The `GtkActionBar` implementation of the `GtkBuildable` interface supports
         * adding children at the start or end sides by specifying “start” or “end” as
         * the “type” attribute of a `<child>` element, or setting the center widget
         * by specifying “center” value.
         *
         * # CSS nodes
         *
         * ```
         * actionbar
         * ╰── revealer
         *     ╰── box
         *         ├── box.start
         *         │   ╰── [start children]
         *         ├── [center widget]
         *         ╰── box.end
         *             ╰── [end children]
         * ```
         *
         * A `GtkActionBar`'s CSS node is called `actionbar`. It contains a `revealer`
         * subnode, which contains a `box` subnode, which contains two `box` subnodes at
         * the start and end of the action bar, with `start` and `end style classes
         * respectively, as well as a center node that represents the center child.
         *
         * Each of the boxes contains children packed for that side.
         */
        class ActionBar extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<ActionBar>;

            // Properties

            /**
             * Controls whether the action bar shows its contents.
             */
            get revealed(): boolean;
            set revealed(val: boolean);

            // Constructors

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

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

            static ['new'](): ActionBar;

            // Methods

            /**
             * Retrieves the center bar widget of the bar.
             * @returns the center `GtkWidget`
             */
            get_center_widget(): Widget | null;
            /**
             * Gets whether the contents of the action bar are revealed.
             * @returns the current value of the [property@Gtk.ActionBar:revealed]   property
             */
            get_revealed(): boolean;
            /**
             * Adds `child` to `action_bar,` packed with reference to the
             * end of the `action_bar`.
             * @param child the `GtkWidget` to be added to @action_bar
             */
            pack_end(child: Widget): void;
            /**
             * Adds `child` to `action_bar,` packed with reference to the
             * start of the `action_bar`.
             * @param child the `GtkWidget` to be added to @action_bar
             */
            pack_start(child: Widget): void;
            /**
             * Removes a child from `action_bar`.
             * @param child the `GtkWidget` to be removed
             */
            remove(child: Widget): void;
            /**
             * Sets the center widget for the `GtkActionBar`.
             * @param center_widget a widget to use for the center
             */
            set_center_widget(center_widget?: Widget | null): void;
            /**
             * Reveals or conceals the content of the action bar.
             *
             * Note: this does not show or hide `action_bar` in the
             * [property`Gtk`.Widget:visible] sense, so revealing has
             * no effect if the action bar is hidden.
             * @param revealed The new value of the property
             */
            set_revealed(revealed: boolean): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ActivateAction {
            // Constructor properties interface

            interface ConstructorProps extends ShortcutAction.ConstructorProps {}
        }

        /**
         * A `GtkShortcutAction` that calls gtk_widget_activate().
         */
        class ActivateAction extends ShortcutAction {
            static $gtype: GObject.GType<ActivateAction>;

            // Constructors

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

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

            // Static methods

            /**
             * Gets the activate action.
             *
             * This is an action that calls gtk_widget_activate()
             * on the given widget upon activation.
             */
            static get(): ActivateAction;
        }

        namespace Adjustment {
            // Signal callback interfaces

            interface Changed {
                (): void;
            }

            interface ValueChanged {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.InitiallyUnowned.ConstructorProps {
                lower: number;
                page_increment: number;
                pageIncrement: number;
                page_size: number;
                pageSize: number;
                step_increment: number;
                stepIncrement: number;
                upper: number;
                value: number;
            }
        }

        /**
         * `GtkAdjustment` is a model for a numeric value.
         *
         * The `GtkAdjustment` has an associated lower and upper bound.
         * It also contains step and page increments, and a page size.
         *
         * Adjustments are used within several GTK widgets, including
         * [class`Gtk`.SpinButton], [class`Gtk`.Viewport], [class`Gtk`.Scrollbar]
         * and [class`Gtk`.Scale].
         *
         * The `GtkAdjustment` object does not update the value itself. Instead
         * it is left up to the owner of the `GtkAdjustment` to control the value.
         */
        class Adjustment extends GObject.InitiallyUnowned {
            static $gtype: GObject.GType<Adjustment>;

            // Properties

            /**
             * The minimum value of the adjustment.
             */
            get lower(): number;
            set lower(val: number);
            /**
             * The page increment of the adjustment.
             */
            get page_increment(): number;
            set page_increment(val: number);
            /**
             * The page increment of the adjustment.
             */
            get pageIncrement(): number;
            set pageIncrement(val: number);
            /**
             * The page size of the adjustment.
             *
             * Note that the page-size is irrelevant and should be set to zero
             * if the adjustment is used for a simple scalar value, e.g. in a
             * `GtkSpinButton`.
             */
            get page_size(): number;
            set page_size(val: number);
            /**
             * The page size of the adjustment.
             *
             * Note that the page-size is irrelevant and should be set to zero
             * if the adjustment is used for a simple scalar value, e.g. in a
             * `GtkSpinButton`.
             */
            get pageSize(): number;
            set pageSize(val: number);
            /**
             * The step increment of the adjustment.
             */
            get step_increment(): number;
            set step_increment(val: number);
            /**
             * The step increment of the adjustment.
             */
            get stepIncrement(): number;
            set stepIncrement(val: number);
            /**
             * The maximum value of the adjustment.
             *
             * Note that values will be restricted by `upper - page-size` if the page-size
             * property is nonzero.
             */
            get upper(): number;
            set upper(val: number);
            /**
             * The value of the adjustment.
             */
            get value(): number;
            set value(val: number);

            // Constructors

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

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

            static ['new'](
                value: number,
                lower: number,
                upper: number,
                step_increment: number,
                page_increment: number,
                page_size: number,
            ): Adjustment;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'changed', callback: (_source: this) => void): number;
            connect_after(signal: 'changed', callback: (_source: this) => void): number;
            emit(signal: 'changed'): void;
            connect(signal: 'value-changed', callback: (_source: this) => void): number;
            connect_after(signal: 'value-changed', callback: (_source: this) => void): number;
            emit(signal: 'value-changed'): void;

            // Virtual methods

            vfunc_changed(): void;
            vfunc_value_changed(): void;

            // Methods

            /**
             * Updates the value property to ensure that the range
             * between `lower` and `upper` is in the current page.
             *
             * The current page goes from `value` to `value` + `page-size`.
             * If the range is larger than the page size, then only the
             * start of it will be in the current page.
             *
             * A [signal`Gtk`.Adjustment::value-changed] signal will be emitted
             * if the value is changed.
             * @param lower the lower value
             * @param upper the upper value
             */
            clamp_page(lower: number, upper: number): void;
            /**
             * Sets all properties of the adjustment at once.
             *
             * Use this function to avoid multiple emissions of the
             * [signal`Gtk`.Adjustment::changed] signal. See
             * [method`Gtk`.Adjustment.set_lower] for an alternative
             * way of compressing multiple emissions of
             * [signal`Gtk`.Adjustment::changed] into one.
             * @param value the new value
             * @param lower the new minimum value
             * @param upper the new maximum value
             * @param step_increment the new step increment
             * @param page_increment the new page increment
             * @param page_size the new page size
             */
            configure(
                value: number,
                lower: number,
                upper: number,
                step_increment: number,
                page_increment: number,
                page_size: number,
            ): void;
            /**
             * Retrieves the minimum value of the adjustment.
             * @returns The current minimum value of the adjustment
             */
            get_lower(): number;
            /**
             * Gets the smaller of step increment and page increment.
             * @returns the minimum increment of @adjustment
             */
            get_minimum_increment(): number;
            /**
             * Retrieves the page increment of the adjustment.
             * @returns The current page increment of the adjustment
             */
            get_page_increment(): number;
            /**
             * Retrieves the page size of the adjustment.
             * @returns The current page size of the adjustment
             */
            get_page_size(): number;
            /**
             * Retrieves the step increment of the adjustment.
             * @returns The current step increment of the adjustment.
             */
            get_step_increment(): number;
            /**
             * Retrieves the maximum value of the adjustment.
             * @returns The current maximum value of the adjustment
             */
            get_upper(): number;
            /**
             * Gets the current value of the adjustment.
             * @returns The current value of the adjustment
             */
            get_value(): number;
            /**
             * Sets the minimum value of the adjustment.
             *
             * When setting multiple adjustment properties via their individual
             * setters, multiple [signal`Gtk`.Adjustment::changed] signals will
             * be emitted. However, since the emission of the
             * [signal`Gtk`.Adjustment::changed] signal is tied to the emission
             * of the ::notify signals of the changed properties, it’s possible
             * to compress the [signal`Gtk`.Adjustment::changed] signals into one
             * by calling g_object_freeze_notify() and g_object_thaw_notify()
             * around the calls to the individual setters.
             *
             * Alternatively, using a single g_object_set() for all the properties
             * to change, or using [method`Gtk`.Adjustment.configure] has the same effect.
             * @param lower the new minimum value
             */
            set_lower(lower: number): void;
            /**
             * Sets the page increment of the adjustment.
             *
             * See [method`Gtk`.Adjustment.set_lower] about how to compress
             * multiple emissions of the [signal`Gtk`.Adjustment::changed]
             * signal when setting multiple adjustment properties.
             * @param page_increment the new page increment
             */
            set_page_increment(page_increment: number): void;
            /**
             * Sets the page size of the adjustment.
             *
             * See [method`Gtk`.Adjustment.set_lower] about how to compress
             * multiple emissions of the [signal`Gtk`.Adjustment::changed]
             * signal when setting multiple adjustment properties.
             * @param page_size the new page size
             */
            set_page_size(page_size: number): void;
            /**
             * Sets the step increment of the adjustment.
             *
             * See [method`Gtk`.Adjustment.set_lower] about how to compress
             * multiple emissions of the [signal`Gtk`.Adjustment::changed]
             * signal when setting multiple adjustment properties.
             * @param step_increment the new step increment
             */
            set_step_increment(step_increment: number): void;
            /**
             * Sets the maximum value of the adjustment.
             *
             * Note that values will be restricted by `upper - page-size`
             * if the page-size property is nonzero.
             *
             * See [method`Gtk`.Adjustment.set_lower] about how to compress
             * multiple emissions of the [signal`Gtk`.Adjustment::changed]
             * signal when setting multiple adjustment properties.
             * @param upper the new maximum value
             */
            set_upper(upper: number): void;
            /**
             * Sets the `GtkAdjustment` value.
             *
             * The value is clamped to lie between [property`Gtk`.Adjustment:lower]
             * and [property`Gtk`.Adjustment:upper].
             *
             * Note that for adjustments which are used in a `GtkScrollbar`,
             * the effective range of allowed values goes from
             * [property`Gtk`.Adjustment:lower] to
             * [property`Gtk`.Adjustment:upper] - [property`Gtk`.Adjustment:page-size].
             * @param value the new value
             */
            set_value(value: number): void;
        }

        namespace AlertDialog {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                buttons: string[];
                cancel_button: number;
                cancelButton: number;
                default_button: number;
                defaultButton: number;
                detail: string;
                message: string;
                modal: boolean;
            }
        }

        /**
         * A `GtkAlertDialog` object collects the arguments that
         * are needed to present a message to the user.
         *
         * The message is shown with the [method`Gtk`.AlertDialog.choose]
         * function.
         *
         * If you don't need to wait for a button to be clicked, you can use
         * [method`Gtk`.AlertDialog.show].
         */
        class AlertDialog extends GObject.Object {
            static $gtype: GObject.GType<AlertDialog>;

            // Properties

            /**
             * Labels for buttons to show in the alert.
             *
             * The labels should be translated and may contain
             * a _ to indicate the mnemonic character.
             *
             * If this property is not set, then a 'Close' button is
             * automatically created.
             */
            get buttons(): string[];
            set buttons(val: string[]);
            /**
             * This property determines what happens when the Escape key is
             * pressed while the alert is shown.
             *
             * If this property holds the index of a button in [property`Gtk`.AlertDialog:buttons],
             * then pressing Escape is treated as if that button was pressed. If it is -1
             * or not a valid index for the `buttons` array, then an error is returned.
             *
             * If `buttons` is `NULL`, then the automatically created 'Close' button
             * is treated as both cancel and default button, so 0 is returned.
             */
            get cancel_button(): number;
            set cancel_button(val: number);
            /**
             * This property determines what happens when the Escape key is
             * pressed while the alert is shown.
             *
             * If this property holds the index of a button in [property`Gtk`.AlertDialog:buttons],
             * then pressing Escape is treated as if that button was pressed. If it is -1
             * or not a valid index for the `buttons` array, then an error is returned.
             *
             * If `buttons` is `NULL`, then the automatically created 'Close' button
             * is treated as both cancel and default button, so 0 is returned.
             */
            get cancelButton(): number;
            set cancelButton(val: number);
            /**
             * This property determines what happens when the Return key is
             * pressed while the alert is shown.
             *
             * If this property holds the index of a button in [property`Gtk`.AlertDialog:buttons],
             * then pressing Return is treated as if that button was pressed. If it is -1
             * or not a valid index for the `buttons` array, then nothing happens.
             *
             * If `buttons` is `NULL`, then the automatically created 'Close' button
             * is treated as both cancel and default button, so 0 is returned.
             */
            get default_button(): number;
            set default_button(val: number);
            /**
             * This property determines what happens when the Return key is
             * pressed while the alert is shown.
             *
             * If this property holds the index of a button in [property`Gtk`.AlertDialog:buttons],
             * then pressing Return is treated as if that button was pressed. If it is -1
             * or not a valid index for the `buttons` array, then nothing happens.
             *
             * If `buttons` is `NULL`, then the automatically created 'Close' button
             * is treated as both cancel and default button, so 0 is returned.
             */
            get defaultButton(): number;
            set defaultButton(val: number);
            /**
             * The detail text for the alert.
             */
            get detail(): string;
            set detail(val: string);
            /**
             * The message for the alert.
             */
            get message(): string;
            set message(val: string);
            /**
             * Whether the alert is modal.
             */
            get modal(): boolean;
            set modal(val: boolean);

            // Constructors

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

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

            // Methods

            /**
             * This function shows the alert to the user.
             *
             * It is ok to pass `NULL` for the callback if the alert
             * does not have more than one button. A simpler API for
             * this case is [method`Gtk`.AlertDialog.show].
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             */
            choose(parent?: Window | null, cancellable?: Gio.Cancellable | null): Promise<number>;
            /**
             * This function shows the alert to the user.
             *
             * It is ok to pass `NULL` for the callback if the alert
             * does not have more than one button. A simpler API for
             * this case is [method`Gtk`.AlertDialog.show].
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call   when the operation is complete
             */
            choose(
                parent: Window | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * This function shows the alert to the user.
             *
             * It is ok to pass `NULL` for the callback if the alert
             * does not have more than one button. A simpler API for
             * this case is [method`Gtk`.AlertDialog.show].
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call   when the operation is complete
             */
            choose(
                parent?: Window | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<number> | void;
            /**
             * Finishes the [method`Gtk`.AlertDialog.choose] call
             * and returns the index of the button that was clicked.
             * @param result a `GAsyncResult`
             * @returns the index of the button that was clicked, or -1 if   the dialog was cancelled and [property@Gtk.AlertDialog:cancel-button]   is not set
             */
            choose_finish(result: Gio.AsyncResult): number;
            /**
             * Returns the button labels for the alert.
             * @returns the button labels
             */
            get_buttons(): string[] | null;
            /**
             * Returns the index of the cancel button.
             * @returns the index of the cancel button, or -1
             */
            get_cancel_button(): number;
            /**
             * Returns the index of the default button.
             * @returns the index of the default button, or -1
             */
            get_default_button(): number;
            /**
             * Returns the detail text that will be shown in the alert.
             * @returns the detail text
             */
            get_detail(): string;
            /**
             * Returns the message that will be shown in the alert.
             * @returns the message
             */
            get_message(): string;
            /**
             * Returns whether the alert blocks interaction
             * with the parent window while it is presented.
             * @returns `TRUE` if the alert is modal
             */
            get_modal(): boolean;
            /**
             * Sets the button labels for the alert.
             * @param labels the new button labels
             */
            set_buttons(labels: string[]): void;
            /**
             * Sets the index of the cancel button.
             *
             * See [property`Gtk`.AlertDialog:cancel-button] for
             * details of how this value is used.
             * @param button the new cancel button
             */
            set_cancel_button(button: number): void;
            /**
             * Sets the index of the default button.
             *
             * See [property`Gtk`.AlertDialog:default-button] for
             * details of how this value is used.
             * @param button the new default button
             */
            set_default_button(button: number): void;
            /**
             * Sets the detail text that will be shown in the alert.
             * @param detail the new detail text
             */
            set_detail(detail: string): void;
            /**
             * Sets the message that will be shown in the alert.
             * @param message the new message
             */
            set_message(message: string): void;
            /**
             * Sets whether the alert blocks interaction
             * with the parent window while it is presented.
             * @param modal the new value
             */
            set_modal(modal: boolean): void;
            /**
             * Show the alert to the user.
             *
             * This function is a simple version of [method`Gtk`.AlertDialog.choose]
             * intended for dialogs with a single button.
             * If you want to cancel the dialog or if the alert has more than one button,
             * you should use that function instead and provide it with a #GCancellable or
             * callback respectively.
             * @param parent the parent `GtkWindow`
             */
            show(parent?: Window | null): void;
        }

        namespace AlternativeTrigger {
            // Constructor properties interface

            interface ConstructorProps extends ShortcutTrigger.ConstructorProps {
                first: ShortcutTrigger;
                second: ShortcutTrigger;
            }
        }

        /**
         * A `GtkShortcutTrigger` that combines two triggers.
         *
         * The `GtkAlternativeTrigger` triggers when either of two trigger.
         *
         * This can be cascaded to combine more than two triggers.
         */
        class AlternativeTrigger extends ShortcutTrigger {
            static $gtype: GObject.GType<AlternativeTrigger>;

            // Properties

            /**
             * The first `GtkShortcutTrigger` to check.
             */
            get first(): ShortcutTrigger;
            /**
             * The second `GtkShortcutTrigger` to check.
             */
            get second(): ShortcutTrigger;

            // Constructors

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

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

            static ['new'](first: ShortcutTrigger, second: ShortcutTrigger): AlternativeTrigger;

            // Methods

            /**
             * Gets the first of the two alternative triggers that may
             * trigger `self`.
             *
             * [method`Gtk`.AlternativeTrigger.get_second] will return
             * the other one.
             * @returns the first alternative trigger
             */
            get_first(): ShortcutTrigger;
            /**
             * Gets the second of the two alternative triggers that may
             * trigger `self`.
             *
             * [method`Gtk`.AlternativeTrigger.get_first] will return
             * the other one.
             * @returns the second alternative trigger
             */
            get_second(): ShortcutTrigger;
        }

        namespace AnyFilter {
            // Constructor properties interface

            interface ConstructorProps<A extends GObject.Object = GObject.Object>
                extends MultiFilter.ConstructorProps,
                    Gio.ListModel.ConstructorProps,
                    Buildable.ConstructorProps {}
        }

        /**
         * `GtkAnyFilter` matches an item when at least one of its filters matches.
         *
         * To add filters to a `GtkAnyFilter`, use [method`Gtk`.MultiFilter.append].
         */
        class AnyFilter<A extends GObject.Object = GObject.Object>
            extends MultiFilter
            implements Gio.ListModel<A>, Buildable
        {
            static $gtype: GObject.GType<AnyFilter>;

            // Constructors

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

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

            static ['new'](): AnyFilter;

            // Inherited methods
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             * @returns the #GType of the items contained in @list.
             */
            get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             * @returns the number of items in @list.
             */
            get_n_items(): number;
            /**
             * Get the item at `position`.
             *
             * If `position` is greater than the number of items in `list,` %NULL is
             * returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.
             *
             * This function is meant to be used by language bindings in place
             * of g_list_model_get_item().
             *
             * See also: g_list_model_get_n_items()
             * @param position the position of the item to fetch
             * @returns the object at @position.
             */
            get_item(position: number): A | null;
            /**
             * Emits the #GListModel::items-changed signal on `list`.
             *
             * This function should only be called by classes implementing
             * #GListModel. It has to be called after the internal representation
             * of `list` has been updated, because handlers connected to this signal
             * might query the new state of the list.
             *
             * Implementations must only make changes to the model (as visible to
             * its consumer) in places that will not cause problems for that
             * consumer.  For models that are driven directly by a write API (such
             * as #GListStore), changes can be reported in response to uses of that
             * API.  For models that represent remote data, changes should only be
             * made from a fresh mainloop dispatch.  It is particularly not
             * permitted to make changes in response to a call to the #GListModel
             * consumer API.
             *
             * Stated another way: in general, it is assumed that code making a
             * series of accesses to the model via the API, without returning to the
             * mainloop, and without calling other code, will continue to view the
             * same contents of the model.
             * @param position the position at which @list changed
             * @param removed the number of items removed
             * @param added the number of items added
             */
            items_changed(position: number, removed: number, added: number): void;
            /**
             * Get the item at `position`. If `position` is greater than the number of
             * items in `list,` %NULL is returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.  See g_list_model_get_n_items().
             *
             * The same #GObject instance may not appear more than once in a #GListModel.
             * @param position the position of the item to fetch
             */
            vfunc_get_item(position: number): A | null;
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             */
            vfunc_get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             */
            vfunc_get_n_items(): number;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace AppChooserButton {
            // Signal callback interfaces

            interface Activate {
                (): void;
            }

            interface Changed {
                (): void;
            }

            interface CustomItemActivated {
                (item_name: string): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    AppChooser.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                heading: string;
                modal: boolean;
                show_default_item: boolean;
                showDefaultItem: boolean;
                show_dialog_item: boolean;
                showDialogItem: boolean;
            }
        }

        /**
         * The `GtkAppChooserButton` lets the user select an application.
         *
         * ![An example GtkAppChooserButton](appchooserbutton.png)
         *
         * Initially, a `GtkAppChooserButton` selects the first application
         * in its list, which will either be the most-recently used application
         * or, if [property`Gtk`.AppChooserButton:show-default-item] is %TRUE, the
         * default application.
         *
         * The list of applications shown in a `GtkAppChooserButton` includes
         * the recommended applications for the given content type. When
         * [property`Gtk`.AppChooserButton:show-default-item] is set, the default
         * application is also included. To let the user chooser other applications,
         * you can set the [property`Gtk`.AppChooserButton:show-dialog-item] property,
         * which allows to open a full [class`Gtk`.AppChooserDialog].
         *
         * It is possible to add custom items to the list, using
         * [method`Gtk`.AppChooserButton.append_custom_item]. These items cause
         * the [signal`Gtk`.AppChooserButton::custom-item-activated] signal to be
         * emitted when they are selected.
         *
         * To track changes in the selected application, use the
         * [signal`Gtk`.AppChooserButton::changed] signal.
         *
         * ## CSS nodes
         *
         * `GtkAppChooserButton` has a single CSS node with the name “appchooserbutton”.
         */
        class AppChooserButton extends Widget implements Accessible, AppChooser, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<AppChooserButton>;

            // Properties

            /**
             * The text to show at the top of the dialog that can be
             * opened from the button.
             *
             * The string may contain Pango markup.
             */
            get heading(): string;
            set heading(val: string);
            /**
             * Whether the app chooser dialog should be modal.
             */
            get modal(): boolean;
            set modal(val: boolean);
            /**
             * Determines whether the dropdown menu shows the default application
             * on top for the provided content type.
             */
            get show_default_item(): boolean;
            set show_default_item(val: boolean);
            /**
             * Determines whether the dropdown menu shows the default application
             * on top for the provided content type.
             */
            get showDefaultItem(): boolean;
            set showDefaultItem(val: boolean);
            /**
             * Determines whether the dropdown menu shows an item to open
             * a `GtkAppChooserDialog`.
             */
            get show_dialog_item(): boolean;
            set show_dialog_item(val: boolean);
            /**
             * Determines whether the dropdown menu shows an item to open
             * a `GtkAppChooserDialog`.
             */
            get showDialogItem(): boolean;
            set showDialogItem(val: boolean);

            // Constructors

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

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

            static ['new'](content_type: string): AppChooserButton;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate', callback: (_source: this) => void): number;
            connect_after(signal: 'activate', callback: (_source: this) => void): number;
            emit(signal: 'activate'): void;
            connect(signal: 'changed', callback: (_source: this) => void): number;
            connect_after(signal: 'changed', callback: (_source: this) => void): number;
            emit(signal: 'changed'): void;
            connect(signal: 'custom-item-activated', callback: (_source: this, item_name: string) => void): number;
            connect_after(
                signal: 'custom-item-activated',
                callback: (_source: this, item_name: string) => void,
            ): number;
            emit(signal: 'custom-item-activated', item_name: string): void;

            // Methods

            /**
             * Appends a custom item to the list of applications that is shown
             * in the popup.
             *
             * The item name must be unique per-widget. Clients can use the
             * provided name as a detail for the
             * [signal`Gtk`.AppChooserButton::custom-item-activated] signal, to add a
             * callback for the activation of a particular custom item in the list.
             *
             * See also [method`Gtk`.AppChooserButton.append_separator].
             * @param name the name of the custom item
             * @param label the label for the custom item
             * @param icon the icon for the custom item
             */
            append_custom_item(name: string, label: string, icon: Gio.Icon): void;
            /**
             * Appends a separator to the list of applications that is shown
             * in the popup.
             */
            append_separator(): void;
            /**
             * Returns the text to display at the top of the dialog.
             * @returns the text to display at the top of the dialog,   or %NULL, in which case a default text is displayed
             */
            get_heading(): string | null;
            /**
             * Gets whether the dialog is modal.
             * @returns %TRUE if the dialog is modal
             */
            get_modal(): boolean;
            /**
             * Returns whether the dropdown menu should show the default
             * application at the top.
             * @returns the value of [property@Gtk.AppChooserButton:show-default-item]
             */
            get_show_default_item(): boolean;
            /**
             * Returns whether the dropdown menu shows an item
             * for a `GtkAppChooserDialog`.
             * @returns the value of [property@Gtk.AppChooserButton:show-dialog-item]
             */
            get_show_dialog_item(): boolean;
            /**
             * Selects a custom item.
             *
             * See [method`Gtk`.AppChooserButton.append_custom_item].
             *
             * Use [method`Gtk`.AppChooser.refresh] to bring the selection
             * to its initial state.
             * @param name the name of the custom item
             */
            set_active_custom_item(name: string): void;
            /**
             * Sets the text to display at the top of the dialog.
             *
             * If the heading is not set, the dialog displays a default text.
             * @param heading a string containing Pango markup
             */
            set_heading(heading: string): void;
            /**
             * Sets whether the dialog should be modal.
             * @param modal %TRUE to make the dialog modal
             */
            set_modal(modal: boolean): void;
            /**
             * Sets whether the dropdown menu of this button should show the
             * default application for the given content type at top.
             * @param setting the new value for [property@Gtk.AppChooserButton:show-default-item]
             */
            set_show_default_item(setting: boolean): void;
            /**
             * Sets whether the dropdown menu of this button should show an
             * entry to trigger a `GtkAppChooserDialog`.
             * @param setting the new value for [property@Gtk.AppChooserButton:show-dialog-item]
             */
            set_show_dialog_item(setting: boolean): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The content type of the `GtkAppChooser` object.
             *
             * See `GContentType` for more information about content types.
             */
            get content_type(): string;
            /**
             * The content type of the `GtkAppChooser` object.
             *
             * See `GContentType` for more information about content types.
             */
            get contentType(): string;
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Returns the currently selected application.
             * @returns a `GAppInfo` for the   currently selected application
             */
            get_app_info(): Gio.AppInfo | null;
            /**
             * Returns the content type for which the `GtkAppChooser`
             * shows applications.
             * @returns the content type of @self. Free with g_free()
             */
            get_content_type(): string;
            /**
             * Reloads the list of applications.
             */
            refresh(): void;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace AppChooserDialog {
            // Constructor properties interface

            interface ConstructorProps
                extends Dialog.ConstructorProps,
                    Accessible.ConstructorProps,
                    AppChooser.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Native.ConstructorProps,
                    Root.ConstructorProps,
                    ShortcutManager.ConstructorProps {
                gfile: Gio.File;
                heading: string;
            }
        }

        /**
         * `GtkAppChooserDialog` shows a `GtkAppChooserWidget` inside a `GtkDialog`.
         *
         * ![An example GtkAppChooserDialog](appchooserdialog.png)
         *
         * Note that `GtkAppChooserDialog` does not have any interesting methods
         * of its own. Instead, you should get the embedded `GtkAppChooserWidget`
         * using [method`Gtk`.AppChooserDialog.get_widget] and call its methods if
         * the generic [iface`Gtk`.AppChooser] interface is not sufficient for
         * your needs.
         *
         * To set the heading that is shown above the `GtkAppChooserWidget`,
         * use [method`Gtk`.AppChooserDialog.set_heading].
         *
         * ## CSS nodes
         *
         * `GtkAppChooserDialog` has a single CSS node with the name `window` and style
         * class `.appchooser`.
         */
        class AppChooserDialog
            extends Dialog
            implements Accessible, AppChooser, Buildable, ConstraintTarget, Native, Root, ShortcutManager
        {
            static $gtype: GObject.GType<AppChooserDialog>;

            // Properties

            /**
             * The GFile used by the `GtkAppChooserDialog`.
             *
             * The dialog's `GtkAppChooserWidget` content type will
             * be guessed from the file, if present.
             */
            get gfile(): Gio.File;
            /**
             * The text to show at the top of the dialog.
             *
             * The string may contain Pango markup.
             */
            get heading(): string;
            set heading(val: string);

            // Constructors

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

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

            static ['new'](parent: Window | null, flags: DialogFlags, file: Gio.File): AppChooserDialog;
            // Conflicted with Gtk.Dialog.new

            static ['new'](...args: never[]): any;

            static new_for_content_type(
                parent: Window | null,
                flags: DialogFlags,
                content_type: string,
            ): AppChooserDialog;

            // Methods

            /**
             * Returns the text to display at the top of the dialog.
             * @returns the text to display at the top of the dialog,   or %NULL, in which case a default text is displayed
             */
            get_heading(): string | null;
            /**
             * Returns the `GtkAppChooserWidget` of this dialog.
             * @returns the `GtkAppChooserWidget` of @self
             */
            get_widget(): Widget;
            /**
             * Sets the text to display at the top of the dialog.
             *
             * If the heading is not set, the dialog displays a default text.
             * @param heading a string containing Pango markup
             */
            set_heading(heading: string): void;

            // Inherited properties
            /**
             * The content type of the `GtkAppChooser` object.
             *
             * See `GContentType` for more information about content types.
             */
            get content_type(): string;
            /**
             * The content type of the `GtkAppChooser` object.
             *
             * See `GContentType` for more information about content types.
             */
            get contentType(): string;
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Returns the currently selected application.
             * @returns a `GAppInfo` for the   currently selected application
             */
            get_app_info(): Gio.AppInfo | null;
            /**
             * Returns the content type for which the `GtkAppChooser`
             * shows applications.
             * @returns the content type of @self. Free with g_free()
             */
            get_content_type(): string;
            /**
             * Reloads the list of applications.
             */
            refresh(): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace AppChooserWidget {
            // Signal callback interfaces

            interface ApplicationActivated {
                (application: Gio.AppInfo): void;
            }

            interface ApplicationSelected {
                (application: Gio.AppInfo): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    AppChooser.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                default_text: string;
                defaultText: string;
                show_all: boolean;
                showAll: boolean;
                show_default: boolean;
                showDefault: boolean;
                show_fallback: boolean;
                showFallback: boolean;
                show_other: boolean;
                showOther: boolean;
                show_recommended: boolean;
                showRecommended: boolean;
            }
        }

        /**
         * `GtkAppChooserWidget` is a widget for selecting applications.
         *
         * It is the main building block for [class`Gtk`.AppChooserDialog].
         * Most applications only need to use the latter; but you can use
         * this widget as part of a larger widget if you have special needs.
         *
         * `GtkAppChooserWidget` offers detailed control over what applications
         * are shown, using the
         * [property`Gtk`.AppChooserWidget:show-default],
         * [property`Gtk`.AppChooserWidget:show-recommended],
         * [property`Gtk`.AppChooserWidget:show-fallback],
         * [property`Gtk`.AppChooserWidget:show-other] and
         * [property`Gtk`.AppChooserWidget:show-all] properties. See the
         * [iface`Gtk`.AppChooser] documentation for more information about these
         * groups of applications.
         *
         * To keep track of the selected application, use the
         * [signal`Gtk`.AppChooserWidget::application-selected] and
         * [signal`Gtk`.AppChooserWidget::application-activated] signals.
         *
         * ## CSS nodes
         *
         * `GtkAppChooserWidget` has a single CSS node with name appchooser.
         */
        class AppChooserWidget extends Widget implements Accessible, AppChooser, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<AppChooserWidget>;

            // Properties

            /**
             * The text that appears in the widget when there are no applications
             * for the given content type.
             */
            get default_text(): string;
            set default_text(val: string);
            /**
             * The text that appears in the widget when there are no applications
             * for the given content type.
             */
            get defaultText(): string;
            set defaultText(val: string);
            /**
             * If %TRUE, the app chooser presents all applications
             * in a single list, without subsections for default,
             * recommended or related applications.
             */
            get show_all(): boolean;
            set show_all(val: boolean);
            /**
             * If %TRUE, the app chooser presents all applications
             * in a single list, without subsections for default,
             * recommended or related applications.
             */
            get showAll(): boolean;
            set showAll(val: boolean);
            /**
             * Determines whether the app chooser should show the default
             * handler for the content type in a separate section.
             *
             * If %FALSE, the default handler is listed among the recommended
             * applications.
             */
            get show_default(): boolean;
            set show_default(val: boolean);
            /**
             * Determines whether the app chooser should show the default
             * handler for the content type in a separate section.
             *
             * If %FALSE, the default handler is listed among the recommended
             * applications.
             */
            get showDefault(): boolean;
            set showDefault(val: boolean);
            /**
             * Determines whether the app chooser should show a section
             * for fallback applications.
             *
             * If %FALSE, the fallback applications are listed among the
             * other applications.
             */
            get show_fallback(): boolean;
            set show_fallback(val: boolean);
            /**
             * Determines whether the app chooser should show a section
             * for fallback applications.
             *
             * If %FALSE, the fallback applications are listed among the
             * other applications.
             */
            get showFallback(): boolean;
            set showFallback(val: boolean);
            /**
             * Determines whether the app chooser should show a section
             * for other applications.
             */
            get show_other(): boolean;
            set show_other(val: boolean);
            /**
             * Determines whether the app chooser should show a section
             * for other applications.
             */
            get showOther(): boolean;
            set showOther(val: boolean);
            /**
             * Determines whether the app chooser should show a section
             * for recommended applications.
             *
             * If %FALSE, the recommended applications are listed
             * among the other applications.
             */
            get show_recommended(): boolean;
            set show_recommended(val: boolean);
            /**
             * Determines whether the app chooser should show a section
             * for recommended applications.
             *
             * If %FALSE, the recommended applications are listed
             * among the other applications.
             */
            get showRecommended(): boolean;
            set showRecommended(val: boolean);

            // Constructors

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

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

            static ['new'](content_type: string): AppChooserWidget;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(
                signal: 'application-activated',
                callback: (_source: this, application: Gio.AppInfo) => void,
            ): number;
            connect_after(
                signal: 'application-activated',
                callback: (_source: this, application: Gio.AppInfo) => void,
            ): number;
            emit(signal: 'application-activated', application: Gio.AppInfo): void;
            connect(
                signal: 'application-selected',
                callback: (_source: this, application: Gio.AppInfo) => void,
            ): number;
            connect_after(
                signal: 'application-selected',
                callback: (_source: this, application: Gio.AppInfo) => void,
            ): number;
            emit(signal: 'application-selected', application: Gio.AppInfo): void;

            // Methods

            /**
             * Returns the text that is shown if there are not applications
             * that can handle the content type.
             * @returns the value of [property@Gtk.AppChooserWidget:default-text]
             */
            get_default_text(): string | null;
            /**
             * Gets whether the app chooser should show all applications
             * in a flat list.
             * @returns the value of [property@Gtk.AppChooserWidget:show-all]
             */
            get_show_all(): boolean;
            /**
             * Gets whether the app chooser should show the default handler
             * for the content type in a separate section.
             * @returns the value of [property@Gtk.AppChooserWidget:show-default]
             */
            get_show_default(): boolean;
            /**
             * Gets whether the app chooser should show related applications
             * for the content type in a separate section.
             * @returns the value of [property@Gtk.AppChooserWidget:show-fallback]
             */
            get_show_fallback(): boolean;
            /**
             * Gets whether the app chooser should show applications
             * which are unrelated to the content type.
             * @returns the value of [property@Gtk.AppChooserWidget:show-other]
             */
            get_show_other(): boolean;
            /**
             * Gets whether the app chooser should show recommended applications
             * for the content type in a separate section.
             * @returns the value of [property@Gtk.AppChooserWidget:show-recommended]
             */
            get_show_recommended(): boolean;
            /**
             * Sets the text that is shown if there are not applications
             * that can handle the content type.
             * @param text the new value for [property@Gtk.AppChooserWidget:default-text]
             */
            set_default_text(text: string): void;
            /**
             * Sets whether the app chooser should show all applications
             * in a flat list.
             * @param setting the new value for [property@Gtk.AppChooserWidget:show-all]
             */
            set_show_all(setting: boolean): void;
            /**
             * Sets whether the app chooser should show the default handler
             * for the content type in a separate section.
             * @param setting the new value for [property@Gtk.AppChooserWidget:show-default]
             */
            set_show_default(setting: boolean): void;
            /**
             * Sets whether the app chooser should show related applications
             * for the content type in a separate section.
             * @param setting the new value for [property@Gtk.AppChooserWidget:show-fallback]
             */
            set_show_fallback(setting: boolean): void;
            /**
             * Sets whether the app chooser should show applications
             * which are unrelated to the content type.
             * @param setting the new value for [property@Gtk.AppChooserWidget:show-other]
             */
            set_show_other(setting: boolean): void;
            /**
             * Sets whether the app chooser should show recommended applications
             * for the content type in a separate section.
             * @param setting the new value for [property@Gtk.AppChooserWidget:show-recommended]
             */
            set_show_recommended(setting: boolean): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The content type of the `GtkAppChooser` object.
             *
             * See `GContentType` for more information about content types.
             */
            get content_type(): string;
            /**
             * The content type of the `GtkAppChooser` object.
             *
             * See `GContentType` for more information about content types.
             */
            get contentType(): string;
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Returns the currently selected application.
             * @returns a `GAppInfo` for the   currently selected application
             */
            get_app_info(): Gio.AppInfo | null;
            /**
             * Returns the content type for which the `GtkAppChooser`
             * shows applications.
             * @returns the content type of @self. Free with g_free()
             */
            get_content_type(): string;
            /**
             * Reloads the list of applications.
             */
            refresh(): void;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace Application {
            // Signal callback interfaces

            interface QueryEnd {
                (): void;
            }

            interface WindowAdded {
                (window: Window): void;
            }

            interface WindowRemoved {
                (window: Window): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Gio.Application.ConstructorProps,
                    Gio.ActionGroup.ConstructorProps,
                    Gio.ActionMap.ConstructorProps {
                active_window: Window;
                activeWindow: Window;
                menubar: Gio.MenuModel;
                register_session: boolean;
                registerSession: boolean;
                screensaver_active: boolean;
                screensaverActive: boolean;
            }
        }

        /**
         * `GtkApplication` is a high-level API for writing applications.
         *
         * It supports many aspects of writing a GTK application in a convenient
         * fashion, without enforcing a one-size-fits-all model.
         *
         * Currently, `GtkApplication` handles GTK initialization, application
         * uniqueness, session management, provides some basic scriptability and
         * desktop shell integration by exporting actions and menus and manages a
         * list of toplevel windows whose life-cycle is automatically tied to the
         * life-cycle of your application.
         *
         * While `GtkApplication` works fine with plain [class`Gtk`.Window]s, it is
         * recommended to use it together with [class`Gtk`.ApplicationWindow].
         *
         * ## Automatic resources
         *
         * `GtkApplication` will automatically load menus from the `GtkBuilder`
         * resource located at "gtk/menus.ui", relative to the application's
         * resource base path (see [method`Gio`.Application.set_resource_base_path]).
         * The menu with the ID "menubar" is taken as the application's
         * menubar. Additional menus (most interesting submenus) can be named
         * and accessed via [method`Gtk`.Application.get_menu_by_id] which allows for
         * dynamic population of a part of the menu structure.
         *
         * Note that automatic resource loading uses the resource base path
         * that is set at construction time and will not work if the resource
         * base path is changed at a later time.
         *
         * It is also possible to provide the menubar manually using
         * [method`Gtk`.Application.set_menubar].
         *
         * `GtkApplication` will also automatically setup an icon search path for
         * the default icon theme by appending "icons" to the resource base
         * path. This allows your application to easily store its icons as
         * resources. See [method`Gtk`.IconTheme.add_resource_path] for more
         * information.
         *
         * If there is a resource located at `gtk/help-overlay.ui` which
         * defines a [class`Gtk`.ShortcutsWindow] with ID `help_overlay` then
         * `GtkApplication` associates an instance of this shortcuts window with
         * each [class`Gtk`.ApplicationWindow] and sets up the keyboard accelerator
         * <kbd>Control</kbd>+<kbd>?</kbd> to open it. To create a menu item that
         * displays the shortcuts window, associate the item with the action
         * `win.show-help-overlay`.
         *
         * `GtkApplication` will also automatically set the application id as the
         * default window icon. Use [func`Gtk`.Window.set_default_icon_name] or
         * [property`Gtk`.Window:icon-name] to override that behavior.
         *
         * ## A simple application
         *
         * [A simple example](https://gitlab.gnome.org/GNOME/gtk/tree/main/examples/bp/bloatpad.c)
         * is available in the GTK source code repository
         *
         * `GtkApplication` optionally registers with a session manager of the
         * users session (if you set the [property`Gtk`.Application:register-session]
         * property) and offers various functionality related to the session
         * life-cycle.
         *
         * An application can block various ways to end the session with
         * the [method`Gtk`.Application.inhibit] function. Typical use cases for
         * this kind of inhibiting are long-running, uninterruptible operations,
         * such as burning a CD or performing a disk backup. The session
         * manager may not honor the inhibitor, but it can be expected to
         * inform the user about the negative consequences of ending the
         * session while inhibitors are present.
         *
         * ## See Also
         *
         * - [Using GtkApplication](https://developer.gnome.org/documentation/tutorials/application.html)
         * - [Getting Started with GTK: Basics](getting_started.html#basics)
         */
        class Application extends Gio.Application implements Gio.ActionGroup, Gio.ActionMap {
            static $gtype: GObject.GType<Application>;

            // Properties

            /**
             * The currently focused window of the application.
             */
            get active_window(): Window;
            /**
             * The currently focused window of the application.
             */
            get activeWindow(): Window;
            /**
             * The `GMenuModel` to be used for the application's menu bar.
             */
            get menubar(): Gio.MenuModel;
            set menubar(val: Gio.MenuModel);
            /**
             * Set this property to `TRUE` to register with the session manager.
             *
             * This will make GTK track the session state (such as the
             * [property`Gtk`.Application:screensaver-active] property).
             */
            get register_session(): boolean;
            set register_session(val: boolean);
            /**
             * Set this property to `TRUE` to register with the session manager.
             *
             * This will make GTK track the session state (such as the
             * [property`Gtk`.Application:screensaver-active] property).
             */
            get registerSession(): boolean;
            set registerSession(val: boolean);
            /**
             * This property is `TRUE` if GTK believes that the screensaver is
             * currently active.
             *
             * GTK only tracks session state (including this) when
             * [property`Gtk`.Application:register-session] is set to %TRUE.
             *
             * Tracking the screensaver state is currently only supported on
             * Linux.
             */
            get screensaver_active(): boolean;
            /**
             * This property is `TRUE` if GTK believes that the screensaver is
             * currently active.
             *
             * GTK only tracks session state (including this) when
             * [property`Gtk`.Application:register-session] is set to %TRUE.
             *
             * Tracking the screensaver state is currently only supported on
             * Linux.
             */
            get screensaverActive(): boolean;

            // Constructors

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

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

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

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'query-end', callback: (_source: this) => void): number;
            connect_after(signal: 'query-end', callback: (_source: this) => void): number;
            emit(signal: 'query-end'): void;
            connect(signal: 'window-added', callback: (_source: this, window: Window) => void): number;
            connect_after(signal: 'window-added', callback: (_source: this, window: Window) => void): number;
            emit(signal: 'window-added', window: Window): void;
            connect(signal: 'window-removed', callback: (_source: this, window: Window) => void): number;
            connect_after(signal: 'window-removed', callback: (_source: this, window: Window) => void): number;
            emit(signal: 'window-removed', window: Window): void;

            // Virtual methods

            /**
             * Signal emitted when a `GtkWindow` is added to
             *    application through gtk_application_add_window().
             * @param window
             */
            vfunc_window_added(window: Window): void;
            /**
             * Signal emitted when a `GtkWindow` is removed from
             *    application, either as a side-effect of being destroyed or
             *    explicitly through gtk_application_remove_window().
             * @param window
             */
            vfunc_window_removed(window: Window): void;

            // Methods

            /**
             * Adds a window to `application`.
             *
             * This call can only happen after the `application` has started;
             * typically, you should add new application windows in response
             * to the emission of the `GApplication::activate` signal.
             *
             * This call is equivalent to setting the [property`Gtk`.Window:application]
             * property of `window` to `application`.
             *
             * Normally, the connection between the application and the window
             * will remain until the window is destroyed, but you can explicitly
             * remove it with [method`Gtk`.Application.remove_window].
             *
             * GTK will keep the `application` running as long as it has
             * any windows.
             * @param window a `GtkWindow`
             */
            add_window(window: Window): void;
            /**
             * Gets the accelerators that are currently associated with
             * the given action.
             * @param detailed_action_name a detailed action name, specifying an action   and target to obtain accelerators for
             * @returns accelerators for `detailed_action_name`
             */
            get_accels_for_action(detailed_action_name: string): string[];
            /**
             * Returns the list of actions (possibly empty) that `accel` maps to.
             *
             * Each item in the list is a detailed action name in the usual form.
             *
             * This might be useful to discover if an accel already exists in
             * order to prevent installation of a conflicting accelerator (from
             * an accelerator editor or a plugin system, for example). Note that
             * having more than one action per accelerator may not be a bad thing
             * and might make sense in cases where the actions never appear in the
             * same context.
             *
             * In case there are no actions for a given accelerator, an empty array
             * is returned. `NULL` is never returned.
             *
             * It is a programmer error to pass an invalid accelerator string.
             *
             * If you are unsure, check it with [func`Gtk`.accelerator_parse] first.
             * @param accel an accelerator that can be parsed by [func@Gtk.accelerator_parse]
             * @returns a %NULL-terminated array of actions for `accel`
             */
            get_actions_for_accel(accel: string): string[];
            /**
             * Gets the “active” window for the application.
             *
             * The active window is the one that was most recently focused (within
             * the application).  This window may not have the focus at the moment
             * if another application has it — this is just the most
             * recently-focused window within this application.
             * @returns the active window
             */
            get_active_window(): Window | null;
            /**
             * Gets a menu from automatically loaded resources.
             *
             * See [the section on Automatic resources](class.Application.html#automatic-resources)
             * for more information.
             * @param id the id of the menu to look up
             * @returns Gets the menu with the   given id from the automatically loaded resources
             */
            get_menu_by_id(id: string): Gio.Menu | null;
            /**
             * Returns the menu model that has been set with
             * [method`Gtk`.Application.set_menubar].
             * @returns the menubar for windows of `application`
             */
            get_menubar(): Gio.MenuModel | null;
            /**
             * Returns the [class`Gtk`.ApplicationWindow] with the given ID.
             *
             * The ID of a `GtkApplicationWindow` can be retrieved with
             * [method`Gtk`.ApplicationWindow.get_id].
             * @param id an identifier number
             * @returns the window for the given `id`
             */
            get_window_by_id(id: number): Window | null;
            /**
             * Gets a list of the [class`Gtk`.Window] instances associated with `application`.
             *
             * The list is sorted by most recently focused window, such that the first
             * element is the currently focused window. (Useful for choosing a parent
             * for a transient window.)
             *
             * The list that is returned should not be modified in any way. It will
             * only remain valid until the next focus change or window creation or
             * deletion.
             * @returns a `GList` of `GtkWindow`   instances
             */
            get_windows(): Window[];
            /**
             * Inform the session manager that certain types of actions should be
             * inhibited.
             *
             * This is not guaranteed to work on all platforms and for all types of
             * actions.
             *
             * Applications should invoke this method when they begin an operation
             * that should not be interrupted, such as creating a CD or DVD. The
             * types of actions that may be blocked are specified by the `flags`
             * parameter. When the application completes the operation it should
             * call [method`Gtk`.Application.uninhibit] to remove the inhibitor. Note
             * that an application can have multiple inhibitors, and all of them must
             * be individually removed. Inhibitors are also cleared when the
             * application exits.
             *
             * Applications should not expect that they will always be able to block
             * the action. In most cases, users will be given the option to force
             * the action to take place.
             *
             * The `reason` message should be short and to the point.
             *
             * If `window` is given, the session manager may point the user to
             * this window to find out more about why the action is inhibited.
             * @param window a `GtkWindow`
             * @param flags what types of actions should be inhibited
             * @param reason a short, human-readable string that explains   why these operations are inhibited
             * @returns A non-zero cookie that is used to uniquely identify this   request. It should be used as an argument to [method@Gtk.Application.uninhibit]   in order to remove the request. If the platform does not support   inhibiting or the request failed for some reason, 0 is returned.
             */
            inhibit(window: Window | null, flags: ApplicationInhibitFlags | null, reason?: string | null): number;
            /**
             * Lists the detailed action names which have associated accelerators.
             *
             * See [method`Gtk`.Application.set_accels_for_action].
             * @returns the detailed action names
             */
            list_action_descriptions(): string[];
            /**
             * Remove a window from `application`.
             *
             * If `window` belongs to `application` then this call is equivalent to
             * setting the [property`Gtk`.Window:application] property of `window` to
             * `NULL`.
             *
             * The application may stop running as a result of a call to this
             * function, if `window` was the last window of the `application`.
             * @param window a `GtkWindow`
             */
            remove_window(window: Window): void;
            /**
             * Sets zero or more keyboard accelerators that will trigger the
             * given action.
             *
             * The first item in `accels` will be the primary accelerator, which may be
             * displayed in the UI.
             *
             * To remove all accelerators for an action, use an empty, zero-terminated
             * array for `accels`.
             *
             * For the `detailed_action_name`, see `g_action_parse_detailed_name()` and
             * `g_action_print_detailed_name()`.
             * @param detailed_action_name a detailed action name, specifying an action   and target to associate accelerators with
             * @param accels a list of accelerators in the format   understood by [func@Gtk.accelerator_parse]
             */
            set_accels_for_action(detailed_action_name: string, accels: string[]): void;
            /**
             * Sets or unsets the menubar for windows of `application`.
             *
             * This is a menubar in the traditional sense.
             *
             * This can only be done in the primary instance of the application,
             * after it has been registered. `GApplication::startup` is a good place
             * to call this.
             *
             * Depending on the desktop environment, this may appear at the top of
             * each window, or at the top of the screen.  In some environments, if
             * both the application menu and the menubar are set, the application
             * menu will be presented as if it were the first item of the menubar.
             * Other environments treat the two as completely separate — for example,
             * the application menu may be rendered by the desktop shell while the
             * menubar (if set) remains in each individual window.
             *
             * Use the base `GActionMap` interface to add actions, to respond to the
             * user selecting these menu items.
             * @param menubar a `GMenuModel`
             */
            set_menubar(menubar?: Gio.MenuModel | null): void;
            /**
             * Removes an inhibitor that has been previously established.
             *
             * See [method`Gtk`.Application.inhibit].
             *
             * Inhibitors are also cleared when the application exits.
             * @param cookie a cookie that was returned by [method@Gtk.Application.inhibit]
             */
            uninhibit(cookie: number): void;

            // Inherited methods
            /**
             * Emits the [signal`Gio`.ActionGroup::action-added] signal on `action_group`.
             *
             * This function should only be called by [type`Gio`.ActionGroup] implementations.
             * @param action_name the name of an action in the group
             */
            action_added(action_name: string): void;
            /**
             * Emits the [signal`Gio`.ActionGroup::action-enabled-changed] signal on `action_group`.
             *
             * This function should only be called by [type`Gio`.ActionGroup] implementations.
             * @param action_name the name of an action in the group
             * @param enabled whether the action is now enabled
             */
            action_enabled_changed(action_name: string, enabled: boolean): void;
            /**
             * Emits the [signal`Gio`.ActionGroup::action-removed] signal on `action_group`.
             *
             * This function should only be called by [type`Gio`.ActionGroup] implementations.
             * @param action_name the name of an action in the group
             */
            action_removed(action_name: string): void;
            /**
             * Emits the [signal`Gio`.ActionGroup::action-state-changed] signal on `action_group`.
             *
             * This function should only be called by [type`Gio`.ActionGroup] implementations.
             * @param action_name the name of an action in the group
             * @param state the new state of the named action
             */
            action_state_changed(action_name: string, state: GLib.Variant): void;
            /**
             * Activate the named action within `action_group`.
             *
             * If the action is expecting a parameter, then the correct type of
             * parameter must be given as `parameter`.  If the action is expecting no
             * parameters then `parameter` must be `NULL`.  See
             * [method`Gio`.ActionGroup.get_action_parameter_type].
             *
             * If the [type`Gio`.ActionGroup] implementation supports asynchronous remote
             * activation over D-Bus, this call may return before the relevant
             * D-Bus traffic has been sent, or any replies have been received. In
             * order to block on such asynchronous activation calls,
             * [method`Gio`.DBusConnection.flush] should be called prior to the code, which
             * depends on the result of the action activation. Without flushing
             * the D-Bus connection, there is no guarantee that the action would
             * have been activated.
             *
             * The following code which runs in a remote app instance, shows an
             * example of a ‘quit’ action being activated on the primary app
             * instance over D-Bus. Here [method`Gio`.DBusConnection.flush] is called
             * before `exit()`. Without `g_dbus_connection_flush()`, the ‘quit’ action
             * may fail to be activated on the primary instance.
             *
             * ```c
             * // call ‘quit’ action on primary instance
             * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
             *
             * // make sure the action is activated now
             * g_dbus_connection_flush (…);
             *
             * g_debug ("Application has been terminated. Exiting.");
             *
             * exit (0);
             * ```
             * @param action_name the name of the action to activate
             * @param parameter parameters to the activation
             */
            activate_action(action_name: string, parameter?: GLib.Variant | null): void;
            /**
             * Request for the state of the named action within `action_group` to be
             * changed to `value`.
             *
             * The action must be stateful and `value` must be of the correct type.
             * See [method`Gio`.ActionGroup.get_action_state_type].
             *
             * This call merely requests a change.  The action may refuse to change
             * its state or may change its state to something other than `value`.
             * See [method`Gio`.ActionGroup.get_action_state_hint].
             *
             * If the `value` GVariant is floating, it is consumed.
             * @param action_name the name of the action to request the change on
             * @param value the new state
             */
            change_action_state(action_name: string, value: GLib.Variant): void;
            /**
             * Checks if the named action within `action_group` is currently enabled.
             *
             * An action must be enabled in order to be activated or in order to
             * have its state changed from outside callers.
             * @param action_name the name of the action to query
             * @returns whether the action is currently enabled
             */
            get_action_enabled(action_name: string): boolean;
            /**
             * Queries the type of the parameter that must be given when activating
             * the named action within `action_group`.
             *
             * When activating the action using [method`Gio`.ActionGroup.activate_action],
             * the [type`GLib`.Variant] given to that function must be of the type returned
             * by this function.
             *
             * In the case that this function returns `NULL`, you must not give any
             * [type`GLib`.Variant], but `NULL` instead.
             *
             * The parameter type of a particular action will never change but it is
             * possible for an action to be removed and for a new action to be added
             * with the same name but a different parameter type.
             * @param action_name the name of the action to query
             * @returns the parameter type
             */
            get_action_parameter_type(action_name: string): GLib.VariantType | null;
            /**
             * Queries the current state of the named action within `action_group`.
             *
             * If the action is not stateful then `NULL` will be returned.  If the
             * action is stateful then the type of the return value is the type
             * given by [method`Gio`.ActionGroup.get_action_state_type].
             *
             * The return value (if non-`NULL`) should be freed with
             * [method`GLib`.Variant.unref] when it is no longer required.
             * @param action_name the name of the action to query
             * @returns the current state of the action
             */
            get_action_state(action_name: string): GLib.Variant | null;
            /**
             * Requests a hint about the valid range of values for the state of the
             * named action within `action_group`.
             *
             * If `NULL` is returned it either means that the action is not stateful
             * or that there is no hint about the valid range of values for the
             * state of the action.
             *
             * If a [type`GLib`.Variant] array is returned then each item in the array is a
             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
             * returned then the tuple specifies the inclusive lower and upper bound
             * of valid values for the state.
             *
             * In any case, the information is merely a hint.  It may be possible to
             * have a state value outside of the hinted range and setting a value
             * within the range may fail.
             *
             * The return value (if non-`NULL`) should be freed with
             * [method`GLib`.Variant.unref] when it is no longer required.
             * @param action_name the name of the action to query
             * @returns the state range hint
             */
            get_action_state_hint(action_name: string): GLib.Variant | null;
            /**
             * Queries the type of the state of the named action within
             * `action_group`.
             *
             * If the action is stateful then this function returns the
             * [type`GLib`.VariantType] of the state.  All calls to
             * [method`Gio`.ActionGroup.change_action_state] must give a [type`GLib`.Variant] of this
             * type and [method`Gio`.ActionGroup.get_action_state] will return a [type`GLib`.Variant]
             * of the same type.
             *
             * If the action is not stateful then this function will return `NULL`.
             * In that case, [method`Gio`.ActionGroup.get_action_state] will return `NULL`
             * and you must not call [method`Gio`.ActionGroup.change_action_state].
             *
             * The state type of a particular action will never change but it is
             * possible for an action to be removed and for a new action to be added
             * with the same name but a different state type.
             * @param action_name the name of the action to query
             * @returns the state type, if the action is stateful
             */
            get_action_state_type(action_name: string): GLib.VariantType | null;
            /**
             * Checks if the named action exists within `action_group`.
             * @param action_name the name of the action to check for
             * @returns whether the named action exists
             */
            has_action(action_name: string): boolean;
            /**
             * Lists the actions contained within `action_group`.
             *
             * The caller is responsible for freeing the list with [func`GLib`.strfreev] when
             * it is no longer required.
             * @returns a `NULL`-terminated array   of the names of the actions in the group
             */
            list_actions(): string[];
            /**
             * Queries all aspects of the named action within an `action_group`.
             *
             * This function acquires the information available from
             * [method`Gio`.ActionGroup.has_action], [method`Gio`.ActionGroup.get_action_enabled],
             * [method`Gio`.ActionGroup.get_action_parameter_type],
             * [method`Gio`.ActionGroup.get_action_state_type],
             * [method`Gio`.ActionGroup.get_action_state_hint] and
             * [method`Gio`.ActionGroup.get_action_state] with a single function call.
             *
             * This provides two main benefits.
             *
             * The first is the improvement in efficiency that comes with not having
             * to perform repeated lookups of the action in order to discover
             * different things about it.  The second is that implementing
             * [type`Gio`.ActionGroup] can now be done by only overriding this one virtual
             * function.
             *
             * The interface provides a default implementation of this function that
             * calls the individual functions, as required, to fetch the
             * information.  The interface also provides default implementations of
             * those functions that call this function.  All implementations,
             * therefore, must override either this function or all of the others.
             *
             * If the action exists, `TRUE` is returned and any of the requested
             * fields (as indicated by having a non-`NULL` reference passed in) are
             * filled.  If the action doesn’t exist, `FALSE` is returned and the
             * fields may or may not have been modified.
             * @param action_name the name of an action in the group
             * @returns `TRUE` if the action exists, else `FALSE`
             */
            query_action(
                action_name: string,
            ): [
                boolean,
                boolean,
                GLib.VariantType | null,
                GLib.VariantType | null,
                GLib.Variant | null,
                GLib.Variant | null,
            ];
            /**
             * Emits the [signal`Gio`.ActionGroup::action-added] signal on `action_group`.
             *
             * This function should only be called by [type`Gio`.ActionGroup] implementations.
             * @param action_name the name of an action in the group
             */
            vfunc_action_added(action_name: string): void;
            /**
             * Emits the [signal`Gio`.ActionGroup::action-enabled-changed] signal on `action_group`.
             *
             * This function should only be called by [type`Gio`.ActionGroup] implementations.
             * @param action_name the name of an action in the group
             * @param enabled whether the action is now enabled
             */
            vfunc_action_enabled_changed(action_name: string, enabled: boolean): void;
            /**
             * Emits the [signal`Gio`.ActionGroup::action-removed] signal on `action_group`.
             *
             * This function should only be called by [type`Gio`.ActionGroup] implementations.
             * @param action_name the name of an action in the group
             */
            vfunc_action_removed(action_name: string): void;
            /**
             * Emits the [signal`Gio`.ActionGroup::action-state-changed] signal on `action_group`.
             *
             * This function should only be called by [type`Gio`.ActionGroup] implementations.
             * @param action_name the name of an action in the group
             * @param state the new state of the named action
             */
            vfunc_action_state_changed(action_name: string, state: GLib.Variant): void;
            /**
             * Activate the named action within `action_group`.
             *
             * If the action is expecting a parameter, then the correct type of
             * parameter must be given as `parameter`.  If the action is expecting no
             * parameters then `parameter` must be `NULL`.  See
             * [method`Gio`.ActionGroup.get_action_parameter_type].
             *
             * If the [type`Gio`.ActionGroup] implementation supports asynchronous remote
             * activation over D-Bus, this call may return before the relevant
             * D-Bus traffic has been sent, or any replies have been received. In
             * order to block on such asynchronous activation calls,
             * [method`Gio`.DBusConnection.flush] should be called prior to the code, which
             * depends on the result of the action activation. Without flushing
             * the D-Bus connection, there is no guarantee that the action would
             * have been activated.
             *
             * The following code which runs in a remote app instance, shows an
             * example of a ‘quit’ action being activated on the primary app
             * instance over D-Bus. Here [method`Gio`.DBusConnection.flush] is called
             * before `exit()`. Without `g_dbus_connection_flush()`, the ‘quit’ action
             * may fail to be activated on the primary instance.
             *
             * ```c
             * // call ‘quit’ action on primary instance
             * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
             *
             * // make sure the action is activated now
             * g_dbus_connection_flush (…);
             *
             * g_debug ("Application has been terminated. Exiting.");
             *
             * exit (0);
             * ```
             * @param action_name the name of the action to activate
             * @param parameter parameters to the activation
             */
            vfunc_activate_action(action_name: string, parameter?: GLib.Variant | null): void;
            /**
             * Request for the state of the named action within `action_group` to be
             * changed to `value`.
             *
             * The action must be stateful and `value` must be of the correct type.
             * See [method`Gio`.ActionGroup.get_action_state_type].
             *
             * This call merely requests a change.  The action may refuse to change
             * its state or may change its state to something other than `value`.
             * See [method`Gio`.ActionGroup.get_action_state_hint].
             *
             * If the `value` GVariant is floating, it is consumed.
             * @param action_name the name of the action to request the change on
             * @param value the new state
             */
            vfunc_change_action_state(action_name: string, value: GLib.Variant): void;
            /**
             * Checks if the named action within `action_group` is currently enabled.
             *
             * An action must be enabled in order to be activated or in order to
             * have its state changed from outside callers.
             * @param action_name the name of the action to query
             */
            vfunc_get_action_enabled(action_name: string): boolean;
            /**
             * Queries the type of the parameter that must be given when activating
             * the named action within `action_group`.
             *
             * When activating the action using [method`Gio`.ActionGroup.activate_action],
             * the [type`GLib`.Variant] given to that function must be of the type returned
             * by this function.
             *
             * In the case that this function returns `NULL`, you must not give any
             * [type`GLib`.Variant], but `NULL` instead.
             *
             * The parameter type of a particular action will never change but it is
             * possible for an action to be removed and for a new action to be added
             * with the same name but a different parameter type.
             * @param action_name the name of the action to query
             */
            vfunc_get_action_parameter_type(action_name: string): GLib.VariantType | null;
            /**
             * Queries the current state of the named action within `action_group`.
             *
             * If the action is not stateful then `NULL` will be returned.  If the
             * action is stateful then the type of the return value is the type
             * given by [method`Gio`.ActionGroup.get_action_state_type].
             *
             * The return value (if non-`NULL`) should be freed with
             * [method`GLib`.Variant.unref] when it is no longer required.
             * @param action_name the name of the action to query
             */
            vfunc_get_action_state(action_name: string): GLib.Variant | null;
            /**
             * Requests a hint about the valid range of values for the state of the
             * named action within `action_group`.
             *
             * If `NULL` is returned it either means that the action is not stateful
             * or that there is no hint about the valid range of values for the
             * state of the action.
             *
             * If a [type`GLib`.Variant] array is returned then each item in the array is a
             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
             * returned then the tuple specifies the inclusive lower and upper bound
             * of valid values for the state.
             *
             * In any case, the information is merely a hint.  It may be possible to
             * have a state value outside of the hinted range and setting a value
             * within the range may fail.
             *
             * The return value (if non-`NULL`) should be freed with
             * [method`GLib`.Variant.unref] when it is no longer required.
             * @param action_name the name of the action to query
             */
            vfunc_get_action_state_hint(action_name: string): GLib.Variant | null;
            /**
             * Queries the type of the state of the named action within
             * `action_group`.
             *
             * If the action is stateful then this function returns the
             * [type`GLib`.VariantType] of the state.  All calls to
             * [method`Gio`.ActionGroup.change_action_state] must give a [type`GLib`.Variant] of this
             * type and [method`Gio`.ActionGroup.get_action_state] will return a [type`GLib`.Variant]
             * of the same type.
             *
             * If the action is not stateful then this function will return `NULL`.
             * In that case, [method`Gio`.ActionGroup.get_action_state] will return `NULL`
             * and you must not call [method`Gio`.ActionGroup.change_action_state].
             *
             * The state type of a particular action will never change but it is
             * possible for an action to be removed and for a new action to be added
             * with the same name but a different state type.
             * @param action_name the name of the action to query
             */
            vfunc_get_action_state_type(action_name: string): GLib.VariantType | null;
            /**
             * Checks if the named action exists within `action_group`.
             * @param action_name the name of the action to check for
             */
            vfunc_has_action(action_name: string): boolean;
            /**
             * Lists the actions contained within `action_group`.
             *
             * The caller is responsible for freeing the list with [func`GLib`.strfreev] when
             * it is no longer required.
             */
            vfunc_list_actions(): string[];
            /**
             * Queries all aspects of the named action within an `action_group`.
             *
             * This function acquires the information available from
             * [method`Gio`.ActionGroup.has_action], [method`Gio`.ActionGroup.get_action_enabled],
             * [method`Gio`.ActionGroup.get_action_parameter_type],
             * [method`Gio`.ActionGroup.get_action_state_type],
             * [method`Gio`.ActionGroup.get_action_state_hint] and
             * [method`Gio`.ActionGroup.get_action_state] with a single function call.
             *
             * This provides two main benefits.
             *
             * The first is the improvement in efficiency that comes with not having
             * to perform repeated lookups of the action in order to discover
             * different things about it.  The second is that implementing
             * [type`Gio`.ActionGroup] can now be done by only overriding this one virtual
             * function.
             *
             * The interface provides a default implementation of this function that
             * calls the individual functions, as required, to fetch the
             * information.  The interface also provides default implementations of
             * those functions that call this function.  All implementations,
             * therefore, must override either this function or all of the others.
             *
             * If the action exists, `TRUE` is returned and any of the requested
             * fields (as indicated by having a non-`NULL` reference passed in) are
             * filled.  If the action doesn’t exist, `FALSE` is returned and the
             * fields may or may not have been modified.
             * @param action_name the name of an action in the group
             */
            vfunc_query_action(
                action_name: string,
            ): [
                boolean,
                boolean,
                GLib.VariantType | null,
                GLib.VariantType | null,
                GLib.Variant | null,
                GLib.Variant | null,
            ];
            /**
             * Adds an action to the `action_map`.
             *
             * If the action map already contains an action with the same name
             * as `action` then the old action is dropped from the action map.
             *
             * The action map takes its own reference on `action`.
             * @param action a [iface@Gio.Action]
             */
            add_action(action: Gio.Action): void;
            /**
             * A convenience function for creating multiple simple actions.
             * See Gio.ActionEntryObj for the structure of the action entry.
             * @param entries Array of action entries to add
             */
            add_action_entries(entries: Gio.ActionEntryObj[]): void;
            /**
             * Looks up the action with the name `action_name` in `action_map`.
             *
             * If no such action exists, returns `NULL`.
             * @param action_name the name of an action
             * @returns a [iface@Gio.Action]
             */
            lookup_action(action_name: string): Gio.Action | null;
            /**
             * Removes the named action from the action map.
             *
             * If no action of this name is in the map then nothing happens.
             * @param action_name the name of the action
             */
            remove_action(action_name: string): void;
            /**
             * Remove actions from a [iface`Gio`.ActionMap]. This is meant as the reverse of
             * [method`Gio`.ActionMap.add_action_entries].
             *
             *
             * ```c
             * static const GActionEntry entries[] = {
             *     { "quit",         activate_quit              },
             *     { "print-string", activate_print_string, "s" }
             * };
             *
             * void
             * add_actions (GActionMap *map)
             * {
             *   g_action_map_add_action_entries (map, entries, G_N_ELEMENTS (entries), NULL);
             * }
             *
             * void
             * remove_actions (GActionMap *map)
             * {
             *   g_action_map_remove_action_entries (map, entries, G_N_ELEMENTS (entries));
             * }
             * ```
             * @param entries a pointer to   the first item in an array of [struct@Gio.ActionEntry] structs
             */
            remove_action_entries(entries: Gio.ActionEntry[]): void;
            /**
             * Adds an action to the `action_map`.
             *
             * If the action map already contains an action with the same name
             * as `action` then the old action is dropped from the action map.
             *
             * The action map takes its own reference on `action`.
             * @param action a [iface@Gio.Action]
             */
            vfunc_add_action(action: Gio.Action): void;
            /**
             * Looks up the action with the name `action_name` in `action_map`.
             *
             * If no such action exists, returns `NULL`.
             * @param action_name the name of an action
             */
            vfunc_lookup_action(action_name: string): Gio.Action | null;
            /**
             * Removes the named action from the action map.
             *
             * If no action of this name is in the map then nothing happens.
             * @param action_name the name of the action
             */
            vfunc_remove_action(action_name: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ApplicationWindow {
            // Constructor properties interface

            interface ConstructorProps
                extends Window.ConstructorProps,
                    Gio.ActionGroup.ConstructorProps,
                    Gio.ActionMap.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Native.ConstructorProps,
                    Root.ConstructorProps,
                    ShortcutManager.ConstructorProps {
                show_menubar: boolean;
                showMenubar: boolean;
            }
        }

        /**
         * `GtkApplicationWindow` is a `GtkWindow` subclass that integrates with
         * `GtkApplication`.
         *
         * Notably, `GtkApplicationWindow` can handle an application menubar.
         *
         * This class implements the `GActionGroup` and `GActionMap` interfaces,
         * to let you add window-specific actions that will be exported by the
         * associated [class`Gtk`.Application], together with its application-wide
         * actions. Window-specific actions are prefixed with the “win.”
         * prefix and application-wide actions are prefixed with the “app.”
         * prefix. Actions must be addressed with the prefixed name when
         * referring to them from a `GMenuModel`.
         *
         * Note that widgets that are placed inside a `GtkApplicationWindow`
         * can also activate these actions, if they implement the
         * [iface`Gtk`.Actionable] interface.
         *
         * The settings [property`Gtk`.Settings:gtk-shell-shows-app-menu] and
         * [property`Gtk`.Settings:gtk-shell-shows-menubar] tell GTK whether the
         * desktop environment is showing the application menu and menubar
         * models outside the application as part of the desktop shell.
         * For instance, on OS X, both menus will be displayed remotely;
         * on Windows neither will be.
         *
         * If the desktop environment does not display the menubar, then
         * `GtkApplicationWindow` will automatically show a menubar for it.
         * This behaviour can be overridden with the
         * [property`Gtk`.ApplicationWindow:show-menubar] property. If the
         * desktop environment does not display the application menu, then
         * it will automatically be included in the menubar or in the windows
         * client-side decorations.
         *
         * See [class`Gtk`.PopoverMenu] for information about the XML language
         * used by `GtkBuilder` for menu models.
         *
         * See also: [method`Gtk`.Application.set_menubar].
         *
         * ## A GtkApplicationWindow with a menubar
         *
         * The code sample below shows how to set up a `GtkApplicationWindow`
         * with a menu bar defined on the [class`Gtk`.Application]:
         *
         * ```c
         * GtkApplication *app = gtk_application_new ("org.gtk.test", 0);
         *
         * GtkBuilder *builder = gtk_builder_new_from_string (
         *     "<interface>"
         *     "  <menu id='menubar'>"
         *     "    <submenu>"
         *     "      <attribute name='label' translatable='yes'>_Edit</attribute>"
         *     "      <item>"
         *     "        <attribute name='label' translatable='yes'>_Copy</attribute>"
         *     "        <attribute name='action'>win.copy</attribute>"
         *     "      </item>"
         *     "      <item>"
         *     "        <attribute name='label' translatable='yes'>_Paste</attribute>"
         *     "        <attribute name='action'>win.paste</attribute>"
         *     "      </item>"
         *     "    </submenu>"
         *     "  </menu>"
         *     "</interface>",
         *     -1);
         *
         * GMenuModel *menubar = G_MENU_MODEL (gtk_builder_get_object (builder, "menubar"));
         * gtk_application_set_menubar (GTK_APPLICATION (app), menubar);
         * g_object_unref (builder);
         *
         * // ...
         *
         * GtkWidget *window = gtk_application_window_new (app);
         * ```
         */
        class ApplicationWindow
            extends Window
            implements
                Gio.ActionGroup,
                Gio.ActionMap,
                Accessible,
                Buildable,
                ConstraintTarget,
                Native,
                Root,
                ShortcutManager
        {
            static $gtype: GObject.GType<ApplicationWindow>;

            // Properties

            /**
             * If this property is %TRUE, the window will display a menubar
             * unless it is shown by the desktop shell.
             *
             * See [method`Gtk`.Application.set_menubar].
             *
             * If %FALSE, the window will not display a menubar, regardless
             * of whether the desktop shell is showing it or not.
             */
            get show_menubar(): boolean;
            set show_menubar(val: boolean);
            /**
             * If this property is %TRUE, the window will display a menubar
             * unless it is shown by the desktop shell.
             *
             * See [method`Gtk`.Application.set_menubar].
             *
             * If %FALSE, the window will not display a menubar, regardless
             * of whether the desktop shell is showing it or not.
             */
            get showMenubar(): boolean;
            set showMenubar(val: boolean);

            // Constructors

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

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

            static ['new'](application: Application): ApplicationWindow;
            // Conflicted with Gtk.Window.new

            static ['new'](...args: never[]): any;

            // Methods

            /**
             * Gets the `GtkShortcutsWindow` that is associated with `window`.
             *
             * See [method`Gtk`.ApplicationWindow.set_help_overlay].
             * @returns the help overlay associated   with @window
             */
            get_help_overlay(): ShortcutsWindow | null;
            /**
             * Returns the unique ID of the window.
             *
             *  If the window has not yet been added to a `GtkApplication`, returns `0`.
             * @returns the unique ID for @window, or `0` if the window   has not yet been added to a `GtkApplication`
             */
            get_id(): number;
            /**
             * Returns whether the window will display a menubar for the app menu
             * and menubar as needed.
             * @returns %TRUE if @window will display a menubar when needed
             */
            get_show_menubar(): boolean;
            /**
             * Associates a shortcuts window with the application window.
             *
             * Additionally, sets up an action with the name
             * `win.show-help-overlay` to present it.
             *
             * `window` takes responsibility for destroying `help_overlay`.
             * @param help_overlay a `GtkShortcutsWindow`
             */
            set_help_overlay(help_overlay?: ShortcutsWindow | null): void;
            /**
             * Sets whether the window will display a menubar for the app menu
             * and menubar as needed.
             * @param show_menubar whether to show a menubar when needed
             */
            set_show_menubar(show_menubar: boolean): void;

            // Inherited properties
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Emits the [signal`Gio`.ActionGroup::action-added] signal on `action_group`.
             *
             * This function should only be called by [type`Gio`.ActionGroup] implementations.
             * @param action_name the name of an action in the group
             */
            action_added(action_name: string): void;
            /**
             * Emits the [signal`Gio`.ActionGroup::action-enabled-changed] signal on `action_group`.
             *
             * This function should only be called by [type`Gio`.ActionGroup] implementations.
             * @param action_name the name of an action in the group
             * @param enabled whether the action is now enabled
             */
            action_enabled_changed(action_name: string, enabled: boolean): void;
            /**
             * Emits the [signal`Gio`.ActionGroup::action-removed] signal on `action_group`.
             *
             * This function should only be called by [type`Gio`.ActionGroup] implementations.
             * @param action_name the name of an action in the group
             */
            action_removed(action_name: string): void;
            /**
             * Emits the [signal`Gio`.ActionGroup::action-state-changed] signal on `action_group`.
             *
             * This function should only be called by [type`Gio`.ActionGroup] implementations.
             * @param action_name the name of an action in the group
             * @param state the new state of the named action
             */
            action_state_changed(action_name: string, state: GLib.Variant): void;
            /**
             * Activate the named action within `action_group`.
             *
             * If the action is expecting a parameter, then the correct type of
             * parameter must be given as `parameter`.  If the action is expecting no
             * parameters then `parameter` must be `NULL`.  See
             * [method`Gio`.ActionGroup.get_action_parameter_type].
             *
             * If the [type`Gio`.ActionGroup] implementation supports asynchronous remote
             * activation over D-Bus, this call may return before the relevant
             * D-Bus traffic has been sent, or any replies have been received. In
             * order to block on such asynchronous activation calls,
             * [method`Gio`.DBusConnection.flush] should be called prior to the code, which
             * depends on the result of the action activation. Without flushing
             * the D-Bus connection, there is no guarantee that the action would
             * have been activated.
             *
             * The following code which runs in a remote app instance, shows an
             * example of a ‘quit’ action being activated on the primary app
             * instance over D-Bus. Here [method`Gio`.DBusConnection.flush] is called
             * before `exit()`. Without `g_dbus_connection_flush()`, the ‘quit’ action
             * may fail to be activated on the primary instance.
             *
             * ```c
             * // call ‘quit’ action on primary instance
             * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
             *
             * // make sure the action is activated now
             * g_dbus_connection_flush (…);
             *
             * g_debug ("Application has been terminated. Exiting.");
             *
             * exit (0);
             * ```
             * @param action_name the name of the action to activate
             * @param parameter parameters to the activation
             */
            activate_action(action_name: string, parameter?: GLib.Variant | null): void;
            // Conflicted with Gtk.Widget.activate_action
            activate_action(...args: never[]): any;
            /**
             * Request for the state of the named action within `action_group` to be
             * changed to `value`.
             *
             * The action must be stateful and `value` must be of the correct type.
             * See [method`Gio`.ActionGroup.get_action_state_type].
             *
             * This call merely requests a change.  The action may refuse to change
             * its state or may change its state to something other than `value`.
             * See [method`Gio`.ActionGroup.get_action_state_hint].
             *
             * If the `value` GVariant is floating, it is consumed.
             * @param action_name the name of the action to request the change on
             * @param value the new state
             */
            change_action_state(action_name: string, value: GLib.Variant): void;
            /**
             * Checks if the named action within `action_group` is currently enabled.
             *
             * An action must be enabled in order to be activated or in order to
             * have its state changed from outside callers.
             * @param action_name the name of the action to query
             * @returns whether the action is currently enabled
             */
            get_action_enabled(action_name: string): boolean;
            /**
             * Queries the type of the parameter that must be given when activating
             * the named action within `action_group`.
             *
             * When activating the action using [method`Gio`.ActionGroup.activate_action],
             * the [type`GLib`.Variant] given to that function must be of the type returned
             * by this function.
             *
             * In the case that this function returns `NULL`, you must not give any
             * [type`GLib`.Variant], but `NULL` instead.
             *
             * The parameter type of a particular action will never change but it is
             * possible for an action to be removed and for a new action to be added
             * with the same name but a different parameter type.
             * @param action_name the name of the action to query
             * @returns the parameter type
             */
            get_action_parameter_type(action_name: string): GLib.VariantType | null;
            /**
             * Queries the current state of the named action within `action_group`.
             *
             * If the action is not stateful then `NULL` will be returned.  If the
             * action is stateful then the type of the return value is the type
             * given by [method`Gio`.ActionGroup.get_action_state_type].
             *
             * The return value (if non-`NULL`) should be freed with
             * [method`GLib`.Variant.unref] when it is no longer required.
             * @param action_name the name of the action to query
             * @returns the current state of the action
             */
            get_action_state(action_name: string): GLib.Variant | null;
            /**
             * Requests a hint about the valid range of values for the state of the
             * named action within `action_group`.
             *
             * If `NULL` is returned it either means that the action is not stateful
             * or that there is no hint about the valid range of values for the
             * state of the action.
             *
             * If a [type`GLib`.Variant] array is returned then each item in the array is a
             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
             * returned then the tuple specifies the inclusive lower and upper bound
             * of valid values for the state.
             *
             * In any case, the information is merely a hint.  It may be possible to
             * have a state value outside of the hinted range and setting a value
             * within the range may fail.
             *
             * The return value (if non-`NULL`) should be freed with
             * [method`GLib`.Variant.unref] when it is no longer required.
             * @param action_name the name of the action to query
             * @returns the state range hint
             */
            get_action_state_hint(action_name: string): GLib.Variant | null;
            /**
             * Queries the type of the state of the named action within
             * `action_group`.
             *
             * If the action is stateful then this function returns the
             * [type`GLib`.VariantType] of the state.  All calls to
             * [method`Gio`.ActionGroup.change_action_state] must give a [type`GLib`.Variant] of this
             * type and [method`Gio`.ActionGroup.get_action_state] will return a [type`GLib`.Variant]
             * of the same type.
             *
             * If the action is not stateful then this function will return `NULL`.
             * In that case, [method`Gio`.ActionGroup.get_action_state] will return `NULL`
             * and you must not call [method`Gio`.ActionGroup.change_action_state].
             *
             * The state type of a particular action will never change but it is
             * possible for an action to be removed and for a new action to be added
             * with the same name but a different state type.
             * @param action_name the name of the action to query
             * @returns the state type, if the action is stateful
             */
            get_action_state_type(action_name: string): GLib.VariantType | null;
            /**
             * Checks if the named action exists within `action_group`.
             * @param action_name the name of the action to check for
             * @returns whether the named action exists
             */
            has_action(action_name: string): boolean;
            /**
             * Lists the actions contained within `action_group`.
             *
             * The caller is responsible for freeing the list with [func`GLib`.strfreev] when
             * it is no longer required.
             * @returns a `NULL`-terminated array   of the names of the actions in the group
             */
            list_actions(): string[];
            /**
             * Queries all aspects of the named action within an `action_group`.
             *
             * This function acquires the information available from
             * [method`Gio`.ActionGroup.has_action], [method`Gio`.ActionGroup.get_action_enabled],
             * [method`Gio`.ActionGroup.get_action_parameter_type],
             * [method`Gio`.ActionGroup.get_action_state_type],
             * [method`Gio`.ActionGroup.get_action_state_hint] and
             * [method`Gio`.ActionGroup.get_action_state] with a single function call.
             *
             * This provides two main benefits.
             *
             * The first is the improvement in efficiency that comes with not having
             * to perform repeated lookups of the action in order to discover
             * different things about it.  The second is that implementing
             * [type`Gio`.ActionGroup] can now be done by only overriding this one virtual
             * function.
             *
             * The interface provides a default implementation of this function that
             * calls the individual functions, as required, to fetch the
             * information.  The interface also provides default implementations of
             * those functions that call this function.  All implementations,
             * therefore, must override either this function or all of the others.
             *
             * If the action exists, `TRUE` is returned and any of the requested
             * fields (as indicated by having a non-`NULL` reference passed in) are
             * filled.  If the action doesn’t exist, `FALSE` is returned and the
             * fields may or may not have been modified.
             * @param action_name the name of an action in the group
             * @returns `TRUE` if the action exists, else `FALSE`
             */
            query_action(
                action_name: string,
            ): [
                boolean,
                boolean,
                GLib.VariantType | null,
                GLib.VariantType | null,
                GLib.Variant | null,
                GLib.Variant | null,
            ];
            /**
             * Emits the [signal`Gio`.ActionGroup::action-added] signal on `action_group`.
             *
             * This function should only be called by [type`Gio`.ActionGroup] implementations.
             * @param action_name the name of an action in the group
             */
            vfunc_action_added(action_name: string): void;
            /**
             * Emits the [signal`Gio`.ActionGroup::action-enabled-changed] signal on `action_group`.
             *
             * This function should only be called by [type`Gio`.ActionGroup] implementations.
             * @param action_name the name of an action in the group
             * @param enabled whether the action is now enabled
             */
            vfunc_action_enabled_changed(action_name: string, enabled: boolean): void;
            /**
             * Emits the [signal`Gio`.ActionGroup::action-removed] signal on `action_group`.
             *
             * This function should only be called by [type`Gio`.ActionGroup] implementations.
             * @param action_name the name of an action in the group
             */
            vfunc_action_removed(action_name: string): void;
            /**
             * Emits the [signal`Gio`.ActionGroup::action-state-changed] signal on `action_group`.
             *
             * This function should only be called by [type`Gio`.ActionGroup] implementations.
             * @param action_name the name of an action in the group
             * @param state the new state of the named action
             */
            vfunc_action_state_changed(action_name: string, state: GLib.Variant): void;
            /**
             * Activate the named action within `action_group`.
             *
             * If the action is expecting a parameter, then the correct type of
             * parameter must be given as `parameter`.  If the action is expecting no
             * parameters then `parameter` must be `NULL`.  See
             * [method`Gio`.ActionGroup.get_action_parameter_type].
             *
             * If the [type`Gio`.ActionGroup] implementation supports asynchronous remote
             * activation over D-Bus, this call may return before the relevant
             * D-Bus traffic has been sent, or any replies have been received. In
             * order to block on such asynchronous activation calls,
             * [method`Gio`.DBusConnection.flush] should be called prior to the code, which
             * depends on the result of the action activation. Without flushing
             * the D-Bus connection, there is no guarantee that the action would
             * have been activated.
             *
             * The following code which runs in a remote app instance, shows an
             * example of a ‘quit’ action being activated on the primary app
             * instance over D-Bus. Here [method`Gio`.DBusConnection.flush] is called
             * before `exit()`. Without `g_dbus_connection_flush()`, the ‘quit’ action
             * may fail to be activated on the primary instance.
             *
             * ```c
             * // call ‘quit’ action on primary instance
             * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
             *
             * // make sure the action is activated now
             * g_dbus_connection_flush (…);
             *
             * g_debug ("Application has been terminated. Exiting.");
             *
             * exit (0);
             * ```
             * @param action_name the name of the action to activate
             * @param parameter parameters to the activation
             */
            vfunc_activate_action(action_name: string, parameter?: GLib.Variant | null): void;
            /**
             * Request for the state of the named action within `action_group` to be
             * changed to `value`.
             *
             * The action must be stateful and `value` must be of the correct type.
             * See [method`Gio`.ActionGroup.get_action_state_type].
             *
             * This call merely requests a change.  The action may refuse to change
             * its state or may change its state to something other than `value`.
             * See [method`Gio`.ActionGroup.get_action_state_hint].
             *
             * If the `value` GVariant is floating, it is consumed.
             * @param action_name the name of the action to request the change on
             * @param value the new state
             */
            vfunc_change_action_state(action_name: string, value: GLib.Variant): void;
            /**
             * Checks if the named action within `action_group` is currently enabled.
             *
             * An action must be enabled in order to be activated or in order to
             * have its state changed from outside callers.
             * @param action_name the name of the action to query
             */
            vfunc_get_action_enabled(action_name: string): boolean;
            /**
             * Queries the type of the parameter that must be given when activating
             * the named action within `action_group`.
             *
             * When activating the action using [method`Gio`.ActionGroup.activate_action],
             * the [type`GLib`.Variant] given to that function must be of the type returned
             * by this function.
             *
             * In the case that this function returns `NULL`, you must not give any
             * [type`GLib`.Variant], but `NULL` instead.
             *
             * The parameter type of a particular action will never change but it is
             * possible for an action to be removed and for a new action to be added
             * with the same name but a different parameter type.
             * @param action_name the name of the action to query
             */
            vfunc_get_action_parameter_type(action_name: string): GLib.VariantType | null;
            /**
             * Queries the current state of the named action within `action_group`.
             *
             * If the action is not stateful then `NULL` will be returned.  If the
             * action is stateful then the type of the return value is the type
             * given by [method`Gio`.ActionGroup.get_action_state_type].
             *
             * The return value (if non-`NULL`) should be freed with
             * [method`GLib`.Variant.unref] when it is no longer required.
             * @param action_name the name of the action to query
             */
            vfunc_get_action_state(action_name: string): GLib.Variant | null;
            /**
             * Requests a hint about the valid range of values for the state of the
             * named action within `action_group`.
             *
             * If `NULL` is returned it either means that the action is not stateful
             * or that there is no hint about the valid range of values for the
             * state of the action.
             *
             * If a [type`GLib`.Variant] array is returned then each item in the array is a
             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
             * returned then the tuple specifies the inclusive lower and upper bound
             * of valid values for the state.
             *
             * In any case, the information is merely a hint.  It may be possible to
             * have a state value outside of the hinted range and setting a value
             * within the range may fail.
             *
             * The return value (if non-`NULL`) should be freed with
             * [method`GLib`.Variant.unref] when it is no longer required.
             * @param action_name the name of the action to query
             */
            vfunc_get_action_state_hint(action_name: string): GLib.Variant | null;
            /**
             * Queries the type of the state of the named action within
             * `action_group`.
             *
             * If the action is stateful then this function returns the
             * [type`GLib`.VariantType] of the state.  All calls to
             * [method`Gio`.ActionGroup.change_action_state] must give a [type`GLib`.Variant] of this
             * type and [method`Gio`.ActionGroup.get_action_state] will return a [type`GLib`.Variant]
             * of the same type.
             *
             * If the action is not stateful then this function will return `NULL`.
             * In that case, [method`Gio`.ActionGroup.get_action_state] will return `NULL`
             * and you must not call [method`Gio`.ActionGroup.change_action_state].
             *
             * The state type of a particular action will never change but it is
             * possible for an action to be removed and for a new action to be added
             * with the same name but a different state type.
             * @param action_name the name of the action to query
             */
            vfunc_get_action_state_type(action_name: string): GLib.VariantType | null;
            /**
             * Checks if the named action exists within `action_group`.
             * @param action_name the name of the action to check for
             */
            vfunc_has_action(action_name: string): boolean;
            /**
             * Lists the actions contained within `action_group`.
             *
             * The caller is responsible for freeing the list with [func`GLib`.strfreev] when
             * it is no longer required.
             */
            vfunc_list_actions(): string[];
            /**
             * Queries all aspects of the named action within an `action_group`.
             *
             * This function acquires the information available from
             * [method`Gio`.ActionGroup.has_action], [method`Gio`.ActionGroup.get_action_enabled],
             * [method`Gio`.ActionGroup.get_action_parameter_type],
             * [method`Gio`.ActionGroup.get_action_state_type],
             * [method`Gio`.ActionGroup.get_action_state_hint] and
             * [method`Gio`.ActionGroup.get_action_state] with a single function call.
             *
             * This provides two main benefits.
             *
             * The first is the improvement in efficiency that comes with not having
             * to perform repeated lookups of the action in order to discover
             * different things about it.  The second is that implementing
             * [type`Gio`.ActionGroup] can now be done by only overriding this one virtual
             * function.
             *
             * The interface provides a default implementation of this function that
             * calls the individual functions, as required, to fetch the
             * information.  The interface also provides default implementations of
             * those functions that call this function.  All implementations,
             * therefore, must override either this function or all of the others.
             *
             * If the action exists, `TRUE` is returned and any of the requested
             * fields (as indicated by having a non-`NULL` reference passed in) are
             * filled.  If the action doesn’t exist, `FALSE` is returned and the
             * fields may or may not have been modified.
             * @param action_name the name of an action in the group
             */
            vfunc_query_action(
                action_name: string,
            ): [
                boolean,
                boolean,
                GLib.VariantType | null,
                GLib.VariantType | null,
                GLib.Variant | null,
                GLib.Variant | null,
            ];
            /**
             * Adds an action to the `action_map`.
             *
             * If the action map already contains an action with the same name
             * as `action` then the old action is dropped from the action map.
             *
             * The action map takes its own reference on `action`.
             * @param action a [iface@Gio.Action]
             */
            add_action(action: Gio.Action): void;
            /**
             * A convenience function for creating multiple simple actions.
             * See Gio.ActionEntryObj for the structure of the action entry.
             * @param entries Array of action entries to add
             */
            add_action_entries(entries: Gio.ActionEntryObj[]): void;
            /**
             * Looks up the action with the name `action_name` in `action_map`.
             *
             * If no such action exists, returns `NULL`.
             * @param action_name the name of an action
             * @returns a [iface@Gio.Action]
             */
            lookup_action(action_name: string): Gio.Action | null;
            /**
             * Removes the named action from the action map.
             *
             * If no action of this name is in the map then nothing happens.
             * @param action_name the name of the action
             */
            remove_action(action_name: string): void;
            /**
             * Remove actions from a [iface`Gio`.ActionMap]. This is meant as the reverse of
             * [method`Gio`.ActionMap.add_action_entries].
             *
             *
             * ```c
             * static const GActionEntry entries[] = {
             *     { "quit",         activate_quit              },
             *     { "print-string", activate_print_string, "s" }
             * };
             *
             * void
             * add_actions (GActionMap *map)
             * {
             *   g_action_map_add_action_entries (map, entries, G_N_ELEMENTS (entries), NULL);
             * }
             *
             * void
             * remove_actions (GActionMap *map)
             * {
             *   g_action_map_remove_action_entries (map, entries, G_N_ELEMENTS (entries));
             * }
             * ```
             * @param entries a pointer to   the first item in an array of [struct@Gio.ActionEntry] structs
             */
            remove_action_entries(entries: Gio.ActionEntry[]): void;
            /**
             * Adds an action to the `action_map`.
             *
             * If the action map already contains an action with the same name
             * as `action` then the old action is dropped from the action map.
             *
             * The action map takes its own reference on `action`.
             * @param action a [iface@Gio.Action]
             */
            vfunc_add_action(action: Gio.Action): void;
            /**
             * Looks up the action with the name `action_name` in `action_map`.
             *
             * If no such action exists, returns `NULL`.
             * @param action_name the name of an action
             */
            vfunc_lookup_action(action_name: string): Gio.Action | null;
            /**
             * Removes the named action from the action map.
             *
             * If no action of this name is in the map then nothing happens.
             * @param action_name the name of the action
             */
            vfunc_remove_action(action_name: string): void;
            /**
             * Returns the renderer that is used for this `GtkNative`.
             * @returns the renderer for @self
             */
            get_renderer(): Gsk.Renderer | null;
            /**
             * Returns the surface of this `GtkNative`.
             * @returns the surface of @self
             */
            get_surface(): Gdk.Surface | null;
            /**
             * Retrieves the surface transform of `self`.
             *
             * This is the translation from `self'`s surface coordinates into
             * `self'`s widget coordinates.
             */
            get_surface_transform(): [number, number];
            /**
             * Realizes a `GtkNative`.
             *
             * This should only be used by subclasses.
             */
            realize(): void;
            /**
             * Unrealizes a `GtkNative`.
             *
             * This should only be used by subclasses.
             */
            unrealize(): void;
            /**
             * Returns the display that this `GtkRoot` is on.
             * @returns the display of @root
             */
            get_display(): Gdk.Display;
            /**
             * Retrieves the current focused widget within the root.
             *
             * Note that this is the widget that would have the focus
             * if the root is active; if the root is not focused then
             * `gtk_widget_has_focus (widget)` will be %FALSE for the
             * widget.
             * @returns the currently focused widget
             */
            get_focus(): Widget | null;
            /**
             * If `focus` is not the current focus widget, and is focusable, sets
             * it as the focus widget for the root.
             *
             * If `focus` is %NULL, unsets the focus widget for the root.
             *
             * To set the focus to a particular widget in the root, it is usually
             * more convenient to use [method`Gtk`.Widget.grab_focus] instead of
             * this function.
             * @param focus widget to be the new focus widget, or %NULL    to unset the focus widget
             */
            set_focus(focus?: Widget | null): void;
            /**
             * Add a `GtkShortcutController` to be managed.
             * @param controller
             */
            vfunc_add_controller(controller: ShortcutController): void;
            /**
             * Remove a `GtkShortcutController` that had previously
             *   been added
             * @param controller
             */
            vfunc_remove_controller(controller: ShortcutController): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace AspectFrame {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                child: Widget;
                obey_child: boolean;
                obeyChild: boolean;
                ratio: number;
                xalign: number;
                yalign: number;
            }
        }

        /**
         * `GtkAspectFrame` preserves the aspect ratio of its child.
         *
         * The frame can respect the aspect ratio of the child widget,
         * or use its own aspect ratio.
         *
         * # CSS nodes
         *
         * `GtkAspectFrame` uses a CSS node with name `aspectframe`.
         *
         * # Accessibility
         *
         * Until GTK 4.10, `GtkAspectFrame` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
         *
         * Starting from GTK 4.12, `GtkAspectFrame` uses the `GTK_ACCESSIBLE_ROLE_GENERIC` role.
         */
        class AspectFrame extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<AspectFrame>;

            // Properties

            /**
             * The child widget.
             */
            get child(): Widget;
            set child(val: Widget);
            /**
             * Whether the `GtkAspectFrame` should use the aspect ratio of its child.
             */
            get obey_child(): boolean;
            set obey_child(val: boolean);
            /**
             * Whether the `GtkAspectFrame` should use the aspect ratio of its child.
             */
            get obeyChild(): boolean;
            set obeyChild(val: boolean);
            /**
             * The aspect ratio to be used by the `GtkAspectFrame`.
             *
             * This property is only used if
             * [property`Gtk`.AspectFrame:obey-child] is set to %FALSE.
             */
            get ratio(): number;
            set ratio(val: number);
            /**
             * The horizontal alignment of the child.
             */
            get xalign(): number;
            set xalign(val: number);
            /**
             * The vertical alignment of the child.
             */
            get yalign(): number;
            set yalign(val: number);

            // Constructors

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

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

            static ['new'](xalign: number, yalign: number, ratio: number, obey_child: boolean): AspectFrame;

            // Methods

            /**
             * Gets the child widget of `self`.
             * @returns the child widget of @self
             */
            get_child(): Widget | null;
            /**
             * Returns whether the child's size request should override
             * the set aspect ratio of the `GtkAspectFrame`.
             * @returns whether to obey the child's size request
             */
            get_obey_child(): boolean;
            /**
             * Returns the desired aspect ratio of the child.
             * @returns the desired aspect ratio
             */
            get_ratio(): number;
            /**
             * Returns the horizontal alignment of the child within the
             * allocation of the `GtkAspectFrame`.
             * @returns the horizontal alignment
             */
            get_xalign(): number;
            /**
             * Returns the vertical alignment of the child within the
             * allocation of the `GtkAspectFrame`.
             * @returns the vertical alignment
             */
            get_yalign(): number;
            /**
             * Sets the child widget of `self`.
             * @param child the child widget
             */
            set_child(child?: Widget | null): void;
            /**
             * Sets whether the aspect ratio of the child's size
             * request should override the set aspect ratio of
             * the `GtkAspectFrame`.
             * @param obey_child If %TRUE, @ratio is ignored, and the aspect    ratio is taken from the requisition of the child.
             */
            set_obey_child(obey_child: boolean): void;
            /**
             * Sets the desired aspect ratio of the child.
             * @param ratio aspect ratio of the child
             */
            set_ratio(ratio: number): void;
            /**
             * Sets the horizontal alignment of the child within the allocation
             * of the `GtkAspectFrame`.
             * @param xalign horizontal alignment, from 0.0 (left aligned) to 1.0 (right aligned)
             */
            set_xalign(xalign: number): void;
            /**
             * Sets the vertical alignment of the child within the allocation
             * of the `GtkAspectFrame`.
             * @param yalign horizontal alignment, from 0.0 (top aligned) to 1.0 (bottom aligned)
             */
            set_yalign(yalign: number): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Assistant {
            // Signal callback interfaces

            interface Apply {
                (): void;
            }

            interface Cancel {
                (): void;
            }

            interface Close {
                (): void;
            }

            interface Escape {
                (): void;
            }

            interface Prepare {
                (page: Widget): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Window.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Native.ConstructorProps,
                    Root.ConstructorProps,
                    ShortcutManager.ConstructorProps {
                pages: Gio.ListModel;
                use_header_bar: number;
                useHeaderBar: number;
            }
        }

        /**
         * `GtkAssistant` is used to represent a complex as a series of steps.
         *
         * ![An example GtkAssistant](assistant.png)
         *
         * Each step consists of one or more pages. `GtkAssistant` guides the user
         * through the pages, and controls the page flow to collect the data needed
         * for the operation.
         *
         * `GtkAssistant` handles which buttons to show and to make sensitive based
         * on page sequence knowledge and the [enum`Gtk`.AssistantPageType] of each
         * page in addition to state information like the *completed* and *committed*
         * page statuses.
         *
         * If you have a case that doesn’t quite fit in `GtkAssistant`s way of
         * handling buttons, you can use the %GTK_ASSISTANT_PAGE_CUSTOM page
         * type and handle buttons yourself.
         *
         * `GtkAssistant` maintains a `GtkAssistantPage` object for each added
         * child, which holds additional per-child properties. You
         * obtain the `GtkAssistantPage` for a child with [method`Gtk`.Assistant.get_page].
         *
         * # GtkAssistant as GtkBuildable
         *
         * The `GtkAssistant` implementation of the `GtkBuildable` interface
         * exposes the `action_area` as internal children with the name
         * “action_area”.
         *
         * To add pages to an assistant in `GtkBuilder`, simply add it as a
         * child to the `GtkAssistant` object. If you need to set per-object
         * properties, create a `GtkAssistantPage` object explicitly, and
         * set the child widget as a property on it.
         *
         * # CSS nodes
         *
         * `GtkAssistant` has a single CSS node with the name window and style
         * class .assistant.
         */
        class Assistant
            extends Window
            implements Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager
        {
            static $gtype: GObject.GType<Assistant>;

            // Properties

            /**
             * `GListModel` containing the pages.
             */
            get pages(): Gio.ListModel;
            /**
             * %TRUE if the assistant uses a `GtkHeaderBar` for action buttons
             * instead of the action-area.
             *
             * For technical reasons, this property is declared as an integer
             * property, but you should only set it to %TRUE or %FALSE.
             */
            get use_header_bar(): number;
            /**
             * %TRUE if the assistant uses a `GtkHeaderBar` for action buttons
             * instead of the action-area.
             *
             * For technical reasons, this property is declared as an integer
             * property, but you should only set it to %TRUE or %FALSE.
             */
            get useHeaderBar(): number;

            // Constructors

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

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

            static ['new'](): Assistant;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'apply', callback: (_source: this) => void): number;
            connect_after(signal: 'apply', callback: (_source: this) => void): number;
            emit(signal: 'apply'): void;
            connect(signal: 'cancel', callback: (_source: this) => void): number;
            connect_after(signal: 'cancel', callback: (_source: this) => void): number;
            emit(signal: 'cancel'): void;
            connect(signal: 'close', callback: (_source: this) => void): number;
            connect_after(signal: 'close', callback: (_source: this) => void): number;
            emit(signal: 'close'): void;
            connect(signal: 'escape', callback: (_source: this) => void): number;
            connect_after(signal: 'escape', callback: (_source: this) => void): number;
            emit(signal: 'escape'): void;
            connect(signal: 'prepare', callback: (_source: this, page: Widget) => void): number;
            connect_after(signal: 'prepare', callback: (_source: this, page: Widget) => void): number;
            emit(signal: 'prepare', page: Widget): void;

            // Methods

            /**
             * Adds a widget to the action area of a `GtkAssistant`.
             * @param child a `GtkWidget`
             */
            add_action_widget(child: Widget): void;
            /**
             * Appends a page to the `assistant`.
             * @param page a `GtkWidget`
             * @returns the index (starting at 0) of the inserted page
             */
            append_page(page: Widget): number;
            /**
             * Erases the visited page history.
             *
             * GTK will then hide the back button on the current page,
             * and removes the cancel button from subsequent pages.
             *
             * Use this when the information provided up to the current
             * page is hereafter deemed permanent and cannot be modified
             * or undone. For example, showing a progress page to track
             * a long-running, unreversible operation after the user has
             * clicked apply on a confirmation page.
             */
            commit(): void;
            /**
             * Returns the page number of the current page.
             * @returns The index (starting from 0) of the current   page in the @assistant, or -1 if the @assistant has no pages,   or no current page
             */
            get_current_page(): number;
            /**
             * Returns the number of pages in the `assistant`
             * @returns the number of pages in the @assistant
             */
            get_n_pages(): number;
            /**
             * Returns the child widget contained in page number `page_num`.
             * @param page_num the index of a page in the @assistant,   or -1 to get the last page
             * @returns the child widget, or %NULL   if @page_num is out of bounds
             */
            get_nth_page(page_num: number): Widget | null;
            /**
             * Returns the `GtkAssistantPage` object for `child`.
             * @param child a child of @assistant
             * @returns the `GtkAssistantPage` for @child
             */
            get_page(child: Widget): AssistantPage;
            /**
             * Gets whether `page` is complete.
             * @param page a page of @assistant
             * @returns %TRUE if @page is complete.
             */
            get_page_complete(page: Widget): boolean;
            /**
             * Gets the title for `page`.
             * @param page a page of @assistant
             * @returns the title for @page
             */
            get_page_title(page: Widget): string;
            /**
             * Gets the page type of `page`.
             * @param page a page of @assistant
             * @returns the page type of @page
             */
            get_page_type(page: Widget): AssistantPageType;
            /**
             * Gets a list model of the assistant pages.
             * @returns A list model of the pages.
             */
            get_pages(): Gio.ListModel;
            /**
             * Inserts a page in the `assistant` at a given position.
             * @param page a `GtkWidget`
             * @param position the index (starting at 0) at which to insert the page,   or -1 to append the page to the @assistant
             * @returns the index (starting from 0) of the inserted page
             */
            insert_page(page: Widget, position: number): number;
            /**
             * Navigate to the next page.
             *
             * It is a programming error to call this function when
             * there is no next page.
             *
             * This function is for use when creating pages of the
             * %GTK_ASSISTANT_PAGE_CUSTOM type.
             */
            next_page(): void;
            /**
             * Prepends a page to the `assistant`.
             * @param page a `GtkWidget`
             * @returns the index (starting at 0) of the inserted page
             */
            prepend_page(page: Widget): number;
            /**
             * Navigate to the previous visited page.
             *
             * It is a programming error to call this function when
             * no previous page is available.
             *
             * This function is for use when creating pages of the
             * %GTK_ASSISTANT_PAGE_CUSTOM type.
             */
            previous_page(): void;
            /**
             * Removes a widget from the action area of a `GtkAssistant`.
             * @param child a `GtkWidget`
             */
            remove_action_widget(child: Widget): void;
            /**
             * Removes the `page_num’`s page from `assistant`.
             * @param page_num the index of a page in the @assistant,   or -1 to remove the last page
             */
            remove_page(page_num: number): void;
            /**
             * Switches the page to `page_num`.
             *
             * Note that this will only be necessary in custom buttons,
             * as the `assistant` flow can be set with
             * gtk_assistant_set_forward_page_func().
             * @param page_num index of the page to switch to, starting from 0.   If negative, the last page will be used. If greater   than the number of pages in the @assistant, nothing   will be done.
             */
            set_current_page(page_num: number): void;
            /**
             * Sets the page forwarding function to be `page_func`.
             *
             * This function will be used to determine what will be
             * the next page when the user presses the forward button.
             * Setting `page_func` to %NULL will make the assistant to
             * use the default forward function, which just goes to the
             * next visible page.
             * @param page_func the `GtkAssistantPageFunc`, or %NULL   to use the default one
             */
            set_forward_page_func(page_func?: AssistantPageFunc | null): void;
            /**
             * Sets whether `page` contents are complete.
             *
             * This will make `assistant` update the buttons state
             * to be able to continue the task.
             * @param page a page of @assistant
             * @param complete the completeness status of the page
             */
            set_page_complete(page: Widget, complete: boolean): void;
            /**
             * Sets a title for `page`.
             *
             * The title is displayed in the header area of the assistant
             * when `page` is the current page.
             * @param page a page of @assistant
             * @param title the new title for @page
             */
            set_page_title(page: Widget, title: string): void;
            /**
             * Sets the page type for `page`.
             *
             * The page type determines the page behavior in the `assistant`.
             * @param page a page of @assistant
             * @param type the new type for @page
             */
            set_page_type(page: Widget, type: AssistantPageType | null): void;
            /**
             * Forces `assistant` to recompute the buttons state.
             *
             * GTK automatically takes care of this in most situations,
             * e.g. when the user goes to a different page, or when the
             * visibility or completeness of a page changes.
             *
             * One situation where it can be necessary to call this
             * function is when changing a value on the current page
             * affects the future page flow of the assistant.
             */
            update_buttons_state(): void;

            // Inherited properties
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Returns the renderer that is used for this `GtkNative`.
             * @returns the renderer for @self
             */
            get_renderer(): Gsk.Renderer | null;
            /**
             * Returns the surface of this `GtkNative`.
             * @returns the surface of @self
             */
            get_surface(): Gdk.Surface | null;
            /**
             * Retrieves the surface transform of `self`.
             *
             * This is the translation from `self'`s surface coordinates into
             * `self'`s widget coordinates.
             */
            get_surface_transform(): [number, number];
            /**
             * Realizes a `GtkNative`.
             *
             * This should only be used by subclasses.
             */
            realize(): void;
            /**
             * Unrealizes a `GtkNative`.
             *
             * This should only be used by subclasses.
             */
            unrealize(): void;
            /**
             * Returns the display that this `GtkRoot` is on.
             * @returns the display of @root
             */
            get_display(): Gdk.Display;
            /**
             * Retrieves the current focused widget within the root.
             *
             * Note that this is the widget that would have the focus
             * if the root is active; if the root is not focused then
             * `gtk_widget_has_focus (widget)` will be %FALSE for the
             * widget.
             * @returns the currently focused widget
             */
            get_focus(): Widget | null;
            /**
             * If `focus` is not the current focus widget, and is focusable, sets
             * it as the focus widget for the root.
             *
             * If `focus` is %NULL, unsets the focus widget for the root.
             *
             * To set the focus to a particular widget in the root, it is usually
             * more convenient to use [method`Gtk`.Widget.grab_focus] instead of
             * this function.
             * @param focus widget to be the new focus widget, or %NULL    to unset the focus widget
             */
            set_focus(focus?: Widget | null): void;
            /**
             * Add a `GtkShortcutController` to be managed.
             * @param controller
             */
            vfunc_add_controller(controller: ShortcutController): void;
            /**
             * Remove a `GtkShortcutController` that had previously
             *   been added
             * @param controller
             */
            vfunc_remove_controller(controller: ShortcutController): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace AssistantPage {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                child: Widget;
                complete: boolean;
                page_type: AssistantPageType;
                pageType: AssistantPageType;
                title: string;
            }
        }

        /**
         * `GtkAssistantPage` is an auxiliary object used by `GtkAssistant.
         */
        class AssistantPage extends GObject.Object {
            static $gtype: GObject.GType<AssistantPage>;

            // Properties

            /**
             * The child widget.
             */
            get child(): Widget;
            /**
             * Whether all required fields are filled in.
             *
             * GTK uses this information to control the sensitivity
             * of the navigation buttons.
             */
            get complete(): boolean;
            set complete(val: boolean);
            /**
             * The type of the assistant page.
             */
            get page_type(): AssistantPageType;
            set page_type(val: AssistantPageType);
            /**
             * The type of the assistant page.
             */
            get pageType(): AssistantPageType;
            set pageType(val: AssistantPageType);
            /**
             * The title of the page.
             */
            get title(): string;
            set title(val: string);

            // Constructors

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

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

            // Methods

            /**
             * Returns the child to which `page` belongs.
             * @returns the child to which @page belongs
             */
            get_child(): Widget;
        }

        namespace BinLayout {
            // Constructor properties interface

            interface ConstructorProps extends LayoutManager.ConstructorProps {}
        }

        /**
         * `GtkBinLayout` is a `GtkLayoutManager` subclass useful for create "bins" of
         * widgets.
         *
         * `GtkBinLayout` will stack each child of a widget on top of each other,
         * using the [property`Gtk`.Widget:hexpand], [property`Gtk`.Widget:vexpand],
         * [property`Gtk`.Widget:halign], and [property`Gtk`.Widget:valign] properties
         * of each child to determine where they should be positioned.
         */
        class BinLayout extends LayoutManager {
            static $gtype: GObject.GType<BinLayout>;

            // Constructors

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

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

            static ['new'](): BinLayout;
        }

        namespace BookmarkList {
            // Constructor properties interface

            interface ConstructorProps<A extends GObject.Object = GObject.Object>
                extends GObject.Object.ConstructorProps,
                    Gio.ListModel.ConstructorProps {
                attributes: string;
                filename: string;
                io_priority: number;
                ioPriority: number;
                item_type: GObject.GType;
                itemType: GObject.GType;
                loading: boolean;
                n_items: number;
                nItems: number;
            }
        }

        /**
         * `GtkBookmarkList` is a list model that wraps `GBookmarkFile`.
         *
         * It presents a `GListModel` and fills it asynchronously with the
         * `GFileInfo`s returned from that function.
         *
         * The `GFileInfo`s in the list have some attributes in the recent
         * namespace added: `recent::private` (boolean) and `recent:applications`
         * (stringv).
         */
        class BookmarkList<A extends GObject.Object = GObject.Object>
            extends GObject.Object
            implements Gio.ListModel<A>
        {
            static $gtype: GObject.GType<BookmarkList>;

            // Properties

            /**
             * The attributes to query.
             */
            get attributes(): string;
            set attributes(val: string);
            /**
             * The bookmark file to load.
             */
            get filename(): string;
            /**
             * Priority used when loading.
             */
            get io_priority(): number;
            set io_priority(val: number);
            /**
             * Priority used when loading.
             */
            get ioPriority(): number;
            set ioPriority(val: number);
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get item_type(): GObject.GType;
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get itemType(): GObject.GType;
            /**
             * %TRUE if files are being loaded.
             */
            get loading(): boolean;
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get n_items(): number;
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get nItems(): number;

            // Constructors

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

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

            static ['new'](filename?: string | null, attributes?: string | null): BookmarkList;

            // Methods

            /**
             * Gets the attributes queried on the children.
             * @returns The queried attributes
             */
            get_attributes(): string | null;
            /**
             * Returns the filename of the bookmark file that
             * this list is loading.
             * @returns the filename of the .xbel file
             */
            get_filename(): string;
            /**
             * Gets the IO priority to use while loading file.
             * @returns The IO priority.
             */
            get_io_priority(): number;
            /**
             * Returns %TRUE if the files are currently being loaded.
             *
             * Files will be added to `self` from time to time while loading is
             * going on. The order in which are added is undefined and may change
             * in between runs.
             * @returns %TRUE if @self is loading
             */
            is_loading(): boolean;
            /**
             * Sets the `attributes` to be enumerated and starts the enumeration.
             *
             * If `attributes` is %NULL, no attributes will be queried, but a list
             * of `GFileInfo`s will still be created.
             * @param attributes the attributes to enumerate
             */
            set_attributes(attributes?: string | null): void;
            /**
             * Sets the IO priority to use while loading files.
             *
             * The default IO priority is %G_PRIORITY_DEFAULT.
             * @param io_priority IO priority to use
             */
            set_io_priority(io_priority: number): void;

            // Inherited methods
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             * @returns the #GType of the items contained in @list.
             */
            get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             * @returns the number of items in @list.
             */
            get_n_items(): number;
            /**
             * Get the item at `position`.
             *
             * If `position` is greater than the number of items in `list,` %NULL is
             * returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.
             *
             * This function is meant to be used by language bindings in place
             * of g_list_model_get_item().
             *
             * See also: g_list_model_get_n_items()
             * @param position the position of the item to fetch
             * @returns the object at @position.
             */
            get_item(position: number): A | null;
            /**
             * Emits the #GListModel::items-changed signal on `list`.
             *
             * This function should only be called by classes implementing
             * #GListModel. It has to be called after the internal representation
             * of `list` has been updated, because handlers connected to this signal
             * might query the new state of the list.
             *
             * Implementations must only make changes to the model (as visible to
             * its consumer) in places that will not cause problems for that
             * consumer.  For models that are driven directly by a write API (such
             * as #GListStore), changes can be reported in response to uses of that
             * API.  For models that represent remote data, changes should only be
             * made from a fresh mainloop dispatch.  It is particularly not
             * permitted to make changes in response to a call to the #GListModel
             * consumer API.
             *
             * Stated another way: in general, it is assumed that code making a
             * series of accesses to the model via the API, without returning to the
             * mainloop, and without calling other code, will continue to view the
             * same contents of the model.
             * @param position the position at which @list changed
             * @param removed the number of items removed
             * @param added the number of items added
             */
            items_changed(position: number, removed: number, added: number): void;
            /**
             * Get the item at `position`. If `position` is greater than the number of
             * items in `list,` %NULL is returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.  See g_list_model_get_n_items().
             *
             * The same #GObject instance may not appear more than once in a #GListModel.
             * @param position the position of the item to fetch
             */
            vfunc_get_item(position: number): A | null;
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             */
            vfunc_get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             */
            vfunc_get_n_items(): number;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace BoolFilter {
            // Constructor properties interface

            interface ConstructorProps extends Filter.ConstructorProps {
                expression: Expression;
                invert: boolean;
            }
        }

        /**
         * `GtkBoolFilter` evaluates a boolean `GtkExpression`
         * to determine whether to include items.
         */
        class BoolFilter extends Filter {
            static $gtype: GObject.GType<BoolFilter>;

            // Properties

            /**
             * The boolean expression to evaluate on item.
             */
            get expression(): Expression;
            set expression(val: Expression);
            /**
             * If the expression result should be inverted.
             */
            get invert(): boolean;
            set invert(val: boolean);

            // Constructors

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

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

            static ['new'](expression?: Expression | null): BoolFilter;

            // Methods

            /**
             * Gets the expression that the filter uses to evaluate if
             * an item should be filtered.
             * @returns a `GtkExpression`
             */
            get_expression(): Expression | null;
            /**
             * Returns whether the filter inverts the expression.
             * @returns %TRUE if the filter inverts
             */
            get_invert(): boolean;
            /**
             * Sets the expression that the filter uses to check if items
             * should be filtered.
             *
             * The expression must have a value type of %G_TYPE_BOOLEAN.
             * @param expression a `GtkExpression`
             */
            set_expression(expression?: Expression | null): void;
            /**
             * Sets whether the filter should invert the expression.
             * @param invert %TRUE to invert
             */
            set_invert(invert: boolean): void;
        }

        namespace Box {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Orientable.ConstructorProps {
                baseline_child: number;
                baselineChild: number;
                baseline_position: BaselinePosition;
                baselinePosition: BaselinePosition;
                homogeneous: boolean;
                spacing: number;
            }
        }

        /**
         * The `GtkBox` widget arranges child widgets into a single row or column.
         *
         * ![An example GtkBox](box.png)
         *
         * Whether it is a row or column depends on the value of its
         * [property`Gtk`.Orientable:orientation] property. Within the other
         * dimension, all children are allocated the same size. Of course, the
         * [property`Gtk`.Widget:halign] and [property`Gtk`.Widget:valign] properties
         * can be used on the children to influence their allocation.
         *
         * Use repeated calls to [method`Gtk`.Box.append] to pack widgets into a
         * `GtkBox` from start to end. Use [method`Gtk`.Box.remove] to remove widgets
         * from the `GtkBox`. [method`Gtk`.Box.insert_child_after] can be used to add
         * a child at a particular position.
         *
         * Use [method`Gtk`.Box.set_homogeneous] to specify whether or not all children
         * of the `GtkBox` are forced to get the same amount of space.
         *
         * Use [method`Gtk`.Box.set_spacing] to determine how much space will be minimally
         * placed between all children in the `GtkBox`. Note that spacing is added
         * *between* the children.
         *
         * Use [method`Gtk`.Box.reorder_child_after] to move a child to a different
         * place in the box.
         *
         * # CSS nodes
         *
         * `GtkBox` uses a single CSS node with name box.
         *
         * # Accessibility
         *
         * Until GTK 4.10, `GtkBox` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
         *
         * Starting from GTK 4.12, `GtkBox` uses the `GTK_ACCESSIBLE_ROLE_GENERIC` role.
         */
        class Box extends Widget implements Accessible, Buildable, ConstraintTarget, Orientable {
            static $gtype: GObject.GType<Box>;

            // Properties

            /**
             * The child that determines the baseline, in vertical orientation.
             */
            get baseline_child(): number;
            set baseline_child(val: number);
            /**
             * The child that determines the baseline, in vertical orientation.
             */
            get baselineChild(): number;
            set baselineChild(val: number);
            /**
             * The position of the baseline aligned widgets if extra space is available.
             */
            get baseline_position(): BaselinePosition;
            set baseline_position(val: BaselinePosition);
            /**
             * The position of the baseline aligned widgets if extra space is available.
             */
            get baselinePosition(): BaselinePosition;
            set baselinePosition(val: BaselinePosition);
            /**
             * Whether the children should all be the same size.
             */
            get homogeneous(): boolean;
            set homogeneous(val: boolean);
            /**
             * The amount of space between children.
             */
            get spacing(): number;
            set spacing(val: number);

            // Constructors

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

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

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

            // Methods

            /**
             * Adds `child` as the last child to `box`.
             * @param child the `GtkWidget` to append
             */
            append(child: Widget): void;
            /**
             * Gets the value set by gtk_box_set_baseline_child().
             * @returns the baseline child
             */
            get_baseline_child(): number;
            /**
             * Gets the value set by gtk_box_set_baseline_position().
             * @returns the baseline position
             */
            get_baseline_position(): BaselinePosition;
            /**
             * Returns whether the box is homogeneous (all children are the
             * same size).
             * @returns %TRUE if the box is homogeneous.
             */
            get_homogeneous(): boolean;
            /**
             * Gets the value set by gtk_box_set_spacing().
             * @returns spacing between children
             */
            get_spacing(): number;
            /**
             * Inserts `child` in the position after `sibling` in the list
             * of `box` children.
             *
             * If `sibling` is %NULL, insert `child` at the first position.
             * @param child the `GtkWidget` to insert
             * @param sibling the sibling after which to insert @child
             */
            insert_child_after(child: Widget, sibling?: Widget | null): void;
            /**
             * Adds `child` as the first child to `box`.
             * @param child the `GtkWidget` to prepend
             */
            prepend(child: Widget): void;
            /**
             * Removes a child widget from `box`.
             *
             * The child must have been added before with
             * [method`Gtk`.Box.append], [method`Gtk`.Box.prepend], or
             * [method`Gtk`.Box.insert_child_after].
             * @param child the child to remove
             */
            remove(child: Widget): void;
            /**
             * Moves `child` to the position after `sibling` in the list
             * of `box` children.
             *
             * If `sibling` is %NULL, move `child` to the first position.
             * @param child the `GtkWidget` to move, must be a child of @box
             * @param sibling the sibling to move @child after
             */
            reorder_child_after(child: Widget, sibling?: Widget | null): void;
            /**
             * Sets the baseline child of a box.
             *
             * This affects only vertical boxes.
             * @param child a child, or -1
             */
            set_baseline_child(child: number): void;
            /**
             * Sets the baseline position of a box.
             *
             * This affects only horizontal boxes with at least one baseline
             * aligned child. If there is more vertical space available than
             * requested, and the baseline is not allocated by the parent then
             * `position` is used to allocate the baseline with respect to the
             * extra space available.
             * @param position a `GtkBaselinePosition`
             */
            set_baseline_position(position: BaselinePosition | null): void;
            /**
             * Sets whether or not all children of `box` are given equal space
             * in the box.
             * @param homogeneous a boolean value, %TRUE to create equal allotments,   %FALSE for variable allotments
             */
            set_homogeneous(homogeneous: boolean): void;
            /**
             * Sets the number of pixels to place between children of `box`.
             * @param spacing the number of pixels to put between children
             */
            set_spacing(spacing: number): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace BoxLayout {
            // Constructor properties interface

            interface ConstructorProps extends LayoutManager.ConstructorProps, Orientable.ConstructorProps {
                baseline_child: number;
                baselineChild: number;
                baseline_position: BaselinePosition;
                baselinePosition: BaselinePosition;
                homogeneous: boolean;
                spacing: number;
            }
        }

        /**
         * `GtkBoxLayout` is a layout manager that arranges children in a single
         * row or column.
         *
         * Whether it is a row or column depends on the value of its
         * [property`Gtk`.Orientable:orientation] property. Within the other dimension
         * all children all allocated the same size. The `GtkBoxLayout` will respect
         * the [property`Gtk`.Widget:halign] and [property`Gtk`.Widget:valign]
         * properties of each child widget.
         *
         * If you want all children to be assigned the same size, you can use
         * the [property`Gtk`.BoxLayout:homogeneous] property.
         *
         * If you want to specify the amount of space placed between each child,
         * you can use the [property`Gtk`.BoxLayout:spacing] property.
         */
        class BoxLayout extends LayoutManager implements Orientable {
            static $gtype: GObject.GType<BoxLayout>;

            // Properties

            /**
             * The child that determines the baseline of the box
             * in vertical layout.
             *
             * If the child does baseline positioning, then its baseline
             * is lined up with the baseline of the box. If it doesn't, then
             * the bottom edge of the child is used.
             */
            get baseline_child(): number;
            set baseline_child(val: number);
            /**
             * The child that determines the baseline of the box
             * in vertical layout.
             *
             * If the child does baseline positioning, then its baseline
             * is lined up with the baseline of the box. If it doesn't, then
             * the bottom edge of the child is used.
             */
            get baselineChild(): number;
            set baselineChild(val: number);
            /**
             * The position of the allocated baseline within the extra space
             * allocated to each child.
             *
             * This property is only relevant for horizontal layouts containing
             * at least one child with a baseline alignment.
             */
            get baseline_position(): BaselinePosition;
            set baseline_position(val: BaselinePosition);
            /**
             * The position of the allocated baseline within the extra space
             * allocated to each child.
             *
             * This property is only relevant for horizontal layouts containing
             * at least one child with a baseline alignment.
             */
            get baselinePosition(): BaselinePosition;
            set baselinePosition(val: BaselinePosition);
            /**
             * Whether the box layout should distribute the available space
             * equally among the children.
             */
            get homogeneous(): boolean;
            set homogeneous(val: boolean);
            /**
             * The space to put between the children.
             */
            get spacing(): number;
            set spacing(val: number);

            // Constructors

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

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

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

            // Methods

            /**
             * Gets the value set by gtk_box_layout_set_baseline_child().
             * @returns the index of the child that determines the baseline     in vertical layout, or -1
             */
            get_baseline_child(): number;
            /**
             * Gets the value set by gtk_box_layout_set_baseline_position().
             * @returns the baseline position
             */
            get_baseline_position(): BaselinePosition;
            /**
             * Returns whether the layout is set to be homogeneous.
             * @returns %TRUE if the layout is homogeneous
             */
            get_homogeneous(): boolean;
            /**
             * Returns the space that `box_layout` puts between children.
             * @returns the spacing of the layout
             */
            get_spacing(): number;
            /**
             * Sets the index of the child that determines the baseline
             * in vertical layout.
             * @param child the child position, or -1
             */
            set_baseline_child(child: number): void;
            /**
             * Sets the baseline position of a box layout.
             *
             * The baseline position affects only horizontal boxes with at least one
             * baseline aligned child. If there is more vertical space available than
             * requested, and the baseline is not allocated by the parent then the
             * given `position` is used to allocate the baseline within the extra
             * space available.
             * @param position a `GtkBaselinePosition`
             */
            set_baseline_position(position: BaselinePosition | null): void;
            /**
             * Sets whether the box layout will allocate the same
             * size to all children.
             * @param homogeneous %TRUE to set the box layout as homogeneous
             */
            set_homogeneous(homogeneous: boolean): void;
            /**
             * Sets how much spacing to put between children.
             * @param spacing the spacing to apply between children
             */
            set_spacing(spacing: number): void;

            // Inherited properties
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Inherited methods
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Builder {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                current_object: GObject.Object;
                currentObject: GObject.Object;
                scope: BuilderScope;
                translation_domain: string;
                translationDomain: string;
            }
        }

        /**
         * A `GtkBuilder` reads XML descriptions of a user interface and
         * instantiates the described objects.
         *
         * To create a `GtkBuilder` from a user interface description, call
         * [ctor`Gtk`.Builder.new_from_file], [ctor`Gtk`.Builder.new_from_resource]
         * or [ctor`Gtk`.Builder.new_from_string].
         *
         * In the (unusual) case that you want to add user interface
         * descriptions from multiple sources to the same `GtkBuilder` you can
         * call [ctor`Gtk`.Builder.new] to get an empty builder and populate it by
         * (multiple) calls to [method`Gtk`.Builder.add_from_file],
         * [method`Gtk`.Builder.add_from_resource] or
         * [method`Gtk`.Builder.add_from_string].
         *
         * A `GtkBuilder` holds a reference to all objects that it has constructed
         * and drops these references when it is finalized. This finalization can
         * cause the destruction of non-widget objects or widgets which are not
         * contained in a toplevel window. For toplevel windows constructed by a
         * builder, it is the responsibility of the user to call
         * [method`Gtk`.Window.destroy] to get rid of them and all the widgets
         * they contain.
         *
         * The functions [method`Gtk`.Builder.get_object] and
         * [method`Gtk`.Builder.get_objects] can be used to access the widgets in
         * the interface by the names assigned to them inside the UI description.
         * Toplevel windows returned by these functions will stay around until the
         * user explicitly destroys them with [method`Gtk`.Window.destroy]. Other
         * widgets will either be part of a larger hierarchy constructed by the
         * builder (in which case you should not have to worry about their lifecycle),
         * or without a parent, in which case they have to be added to some container
         * to make use of them. Non-widget objects need to be reffed with
         * g_object_ref() to keep them beyond the lifespan of the builder.
         *
         * ## GtkBuilder UI Definitions
         *
         * `GtkBuilder` parses textual descriptions of user interfaces which are
         * specified in XML format. We refer to these descriptions as “GtkBuilder
         * UI definitions” or just “UI definitions” if the context is clear.
         *
         * ### Structure of UI definitions
         *
         * UI definition files are always encoded in UTF-8.
         *
         * The toplevel element is `<interface>`. It optionally takes a “domain”
         * attribute, which will make the builder look for translated strings
         * using `dgettext()` in the domain specified. This can also be done by
         * calling [method`Gtk`.Builder.set_translation_domain] on the builder.
         * For example:
         *
         * ```xml
         * <?xml version="1.0" encoding="UTF-8">
         * <interface domain="your-app">
         *   ...
         * </interface>
         * ```
         *
         * ### Requirements
         *
         * The target toolkit version(s) are described by `<requires>` elements,
         * the “lib” attribute specifies the widget library in question (currently
         * the only supported value is “gtk”) and the “version” attribute specifies
         * the target version in the form “`<major>`.`<minor>`”. `GtkBuilder` will
         * error out if the version requirements are not met. For example:
         *
         * ```xml
         * <?xml version="1.0" encoding="UTF-8">
         * <interface domain="your-app">
         *   <requires lib="gtk" version="4.0" />
         * </interface>
         * ```
         *
         * ### Objects
         *
         * Objects are defined as children of the `<interface>` element.
         *
         * Objects are described by `<object>` elements, which can contain
         * `<property>` elements to set properties, `<signal>` elements which
         * connect signals to handlers, and `<child>` elements, which describe
         * child objects.
         *
         * Typically, the specific kind of object represented by an `<object>`
         * element is specified by the “class” attribute. If the type has not
         * been loaded yet, GTK tries to find the `get_type()` function from the
         * class name by applying heuristics. This works in most cases, but if
         * necessary, it is possible to specify the name of the `get_type()`
         * function explicitly with the "type-func" attribute. If your UI definition
         * is referencing internal types, you should make sure to call
         * `g_type_ensure()` for each object type before parsing the UI definition.
         *
         * Objects may be given a name with the “id” attribute, which allows the
         * application to retrieve them from the builder with
         * [method`Gtk`.Builder.get_object]. An id is also necessary to use the
         * object as property value in other parts of the UI definition. GTK
         * reserves ids starting and ending with `___` (three consecutive
         * underscores) for its own purposes.
         *
         * ### Properties
         *
         * Setting properties of objects is pretty straightforward with the
         * `<property>` element: the “name” attribute specifies the name of the
         * property, and the content of the element specifies the value:
         *
         * ```xml
         * <object class="GtkButton">
         *   <property name="label">Hello, world</property>
         * </object>
         * ```
         *
         * If the “translatable” attribute is set to a true value, GTK uses
         * `gettext()` (or `dgettext()` if the builder has a translation domain set)
         * to find a translation for the value. This happens before the value
         * is parsed, so it can be used for properties of any type, but it is
         * probably most useful for string properties. It is also possible to
         * specify a context to disambiguate short strings, and comments which
         * may help the translators:
         *
         * ```xml
         * <object class="GtkButton">
         *   <property name="label" translatable="yes" context="button">Hello, world</property>
         * </object>
         * ```
         *
         * `GtkBuilder` can parse textual representations for the most common
         * property types:
         *
         * - characters
         * - strings
         * - integers
         * - floating-point numbers
         * - booleans (strings like “TRUE”, “t”, “yes”, “y”, “1” are interpreted
         *   as true values, strings like “FALSE”, “f”, “no”, “n”, “0” are interpreted
         *   as false values)
         * - enumeration types (can be specified by their full C identifier their short
         *   name used when registering the enumeration type, or their integer value)
         * - flag types (can be specified by their C identifier, short name, integer
         *   value, and optionally combined with “|” for bitwise OR, e.g.
         *   “GTK_INPUT_HINT_EMOJI|GTK_INPUT_HINT_LOWERCASE”, or “emoji|lowercase”)
         * - colors (in a format understood by [method`Gdk`.RGBA.parse])
         * - `GVariant` (can be specified in the format understood by
         *    [func`GLib`.Variant.parse])
         * - pixbufs (can be specified as an object id, a resource path or a filename of an image file to load relative to the Builder file or the CWD if [method`Gtk`.Builder.add_from_string] was used)
         * - GFile (like pixbufs, can be specified as an object id, a URI or a filename of a file to load relative to the Builder file or the CWD if [method`Gtk`.Builder.add_from_string] was used)
         *
         * Objects can be referred to by their name and by default refer to
         * objects declared in the local XML fragment and objects exposed via
         * [method`Gtk`.Builder.expose_object]. In general, `GtkBuilder` allows
         * forward references to objects declared in the local XML; an object
         * doesn’t have to be constructed before it can be referred to. The
         * exception to this rule is that an object has to be constructed before
         * it can be used as the value of a construct-only property.
         *
         * ### Child objects
         *
         * Many widgets have properties for child widgets, such as
         * [property`Gtk`.Expander:child]. In this case, the preferred way to
         * specify the child widget in a ui file is to simply set the property:
         *
         * ```xml
         * <object class="GtkExpander">
         *   <property name="child">
         *     <object class="GtkLabel">
         *     ...
         *     </object>
         *   </property>
         * </object>
         * ```
         *
         * Generic containers that can contain an arbitrary number of children,
         * such as [class`Gtk`.Box] instead use the `<child>` element. A `<child>`
         * element contains an `<object>` element which describes the child object.
         * Most often, child objects are widgets inside a container, but they can
         * also be, e.g., actions in an action group, or columns in a tree model.
         *
         * Any object type that implements the [iface`Gtk`.Buildable] interface can
         * specify how children may be added to it. Since many objects and widgets that
         * are included with GTK already implement the `GtkBuildable` interface,
         * typically child objects can be added using the `<child>` element without
         * having to be concerned about the underlying implementation.
         *
         * See the [`GtkWidget` documentation](class.Widget.html#gtkwidget-as-gtkbuildable)
         * for many examples of using `GtkBuilder` with widgets, including setting
         * child objects using the `<child>` element.
         *
         * A noteworthy special case to the general rule that only objects implementing
         * `GtkBuildable` may specify how to handle the `<child>` element is that
         * `GtkBuilder` provides special support for adding objects to a
         * [class`Gio`.ListStore] by using the `<child>` element. For instance:
         *
         * ```xml
         * <object class="GListStore">
         *   <property name="item-type">MyObject</property>
         *   <child>
         *     <object class="MyObject" />
         *   </child>
         *   ...
         * </object>
         * ```
         *
         * ### Property bindings
         *
         * It is also possible to bind a property value to another object's
         * property value using the attributes "bind-source" to specify the
         * source object of the binding, and optionally, "bind-property" and
         * "bind-flags" to specify the source property and source binding flags
         * respectively. Internally, `GtkBuilder` implements this using
         * [class`GObject`.Binding] objects.
         *
         * For instance, in the example below the “label” property of the
         * `bottom_label` widget is bound to the “label” property of the
         * `top_button` widget:
         *
         * ```xml
         * <object class="GtkBox">
         *   <property name="orientation">vertical</property>
         *   <child>
         *     <object class="GtkButton" id="top_button">
         *       <property name="label">Hello, world</property>
         *     </object>
         *   </child>
         *   <child>
         *     <object class="GtkLabel" id="bottom_label">
         *       <property name="label"
         *                 bind-source="top_button"
         *                 bind-property="label"
         *                 bind-flags="sync-create" />
         *     </object>
         *   </child>
         * </object>
         * ```
         *
         * For more information, see the documentation of the
         * [method`GObject`.Object.bind_property] method.
         *
         * Please note that another way to set up bindings between objects in .ui files
         * is to use the `GtkExpression` methodology. See the
         * [`GtkExpression` documentation](class.Expression.html#gtkexpression-in-ui-files)
         * for more information.
         *
         * ### Internal children
         *
         * Sometimes it is necessary to refer to widgets which have implicitly
         * been constructed by GTK as part of a composite widget, to set
         * properties on them or to add further children (e.g. the content area
         * of a `GtkDialog`). This can be achieved by setting the “internal-child”
         * property of the `<child>` element to a true value. Note that `GtkBuilder`
         * still requires an `<object>` element for the internal child, even if it
         * has already been constructed.
         *
         * ### Specialized children
         *
         * A number of widgets have different places where a child can be added
         * (e.g. tabs vs. page content in notebooks). This can be reflected in
         * a UI definition by specifying the “type” attribute on a `<child>`
         * The possible values for the “type” attribute are described in the
         * sections describing the widget-specific portions of UI definitions.
         *
         * ### Signal handlers and function pointers
         *
         * Signal handlers are set up with the `<signal>` element. The “name”
         * attribute specifies the name of the signal, and the “handler” attribute
         * specifies the function to connect to the signal.
         *
         * ```xml
         * <object class="GtkButton" id="hello_button">
         *   <signal name="clicked" handler="hello_button__clicked" />
         * </object>
         * ```
         *
         * The remaining attributes, “after”, “swapped” and “object”, have the
         * same meaning as the corresponding parameters of the
         * [func`GObject`.signal_connect_object] or [func`GObject`.signal_connect_data]
         * functions:
         *
         * - “after” matches the `G_CONNECT_AFTER` flag, and will ensure that the
         *   handler is called after the default class closure for the signal
         * - “swapped” matches the `G_CONNECT_SWAPPED` flag, and will swap the
         *   instance and closure arguments when invoking the signal handler
         * - “object” will bind the signal handler to the lifetime of the object
         *   referenced by the attribute
         *
         * By default "swapped" will be set to "yes" if not specified otherwise, in
         * the case where "object" is set, for convenience. A “last_modification_time”
         * attribute is also allowed, but it does not have a meaning to the builder.
         *
         * When compiling applications for Windows, you must declare signal callbacks
         * with the `G_MODULE_EXPORT` decorator, or they will not be put in the symbol
         * table:
         *
         * ```c
         * G_MODULE_EXPORT void
         * hello_button__clicked (GtkButton *button,
         *                        gpointer data)
         * {
         *   // ...
         * }
         * ```
         *
         * On Linux and Unix, this is not necessary; applications should instead
         * be compiled with the `-Wl,--export-dynamic` argument inside their compiler
         * flags, and linked against `gmodule-export-2.0`.
         *
         * ## Example UI Definition
         *
         * ```xml
         * <interface>
         *   <object class="GtkDialog" id="dialog1">
         *     <child internal-child="content_area">
         *       <object class="GtkBox">
         *         <child internal-child="action_area">
         *           <object class="GtkBox">
         *             <child>
         *               <object class="GtkButton" id="ok_button">
         *                 <property name="label" translatable="yes">_Ok</property>
         *                 <property name="use-underline">True</property>
         *                 <signal name="clicked" handler="ok_button_clicked"/>
         *               </object>
         *             </child>
         *           </object>
         *         </child>
         *       </object>
         *     </child>
         *   </object>
         * </interface>
         * ```
         *
         * ## Using GtkBuildable for extending UI definitions
         *
         * Objects can implement the [iface`Gtk`.Buildable] interface to add custom
         * elements and attributes to the XML. Typically, any extension will be
         * documented in each type that implements the interface.
         *
         * ## Templates
         *
         * When describing a [class`Gtk`.Widget], you can use the `<template>` tag to
         * describe a UI bound to a specific widget type. GTK will automatically load
         * the UI definition when instantiating the type, and bind children and
         * signal handlers to instance fields and function symbols.
         *
         * For more information, see the [`GtkWidget` documentation](class.Widget.html#building-composite-widgets-from-template-xml)
         * for details.
         */
        class Builder extends GObject.Object {
            static $gtype: GObject.GType<Builder>;

            // Properties

            /**
             * The object the builder is evaluating for.
             */
            get current_object(): GObject.Object;
            set current_object(val: GObject.Object);
            /**
             * The object the builder is evaluating for.
             */
            get currentObject(): GObject.Object;
            set currentObject(val: GObject.Object);
            /**
             * The scope the builder is operating in
             */
            get scope(): BuilderScope;
            set scope(val: BuilderScope);
            /**
             * The translation domain used when translating property values that
             * have been marked as translatable.
             *
             * If the translation domain is %NULL, `GtkBuilder` uses gettext(),
             * otherwise g_dgettext().
             */
            get translation_domain(): string;
            set translation_domain(val: string);
            /**
             * The translation domain used when translating property values that
             * have been marked as translatable.
             *
             * If the translation domain is %NULL, `GtkBuilder` uses gettext(),
             * otherwise g_dgettext().
             */
            get translationDomain(): string;
            set translationDomain(val: string);

            // Constructors

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

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

            static ['new'](): Builder;

            static new_from_file(filename: string): Builder;

            static new_from_resource(resource_path: string): Builder;

            static new_from_string(string: string, length: number): Builder;

            // Methods

            /**
             * Parses a file containing a UI definition and merges it with
             * the current contents of `builder`.
             *
             * This function is useful if you need to call
             * [method`Gtk`.Builder.set_current_object]) to add user data to
             * callbacks before loading GtkBuilder UI. Otherwise, you probably
             * want [ctor`Gtk`.Builder.new_from_file] instead.
             *
             * If an error occurs, 0 will be returned and `error` will be assigned a
             * `GError` from the `GTK_BUILDER_ERROR`, `G_MARKUP_ERROR` or `G_FILE_ERROR`
             * domains.
             *
             * It’s not really reasonable to attempt to handle failures of this
             * call. You should not use this function with untrusted files (ie:
             * files that are not part of your application). Broken `GtkBuilder`
             * files can easily crash your program, and it’s possible that memory
             * was leaked leading up to the reported failure. The only reasonable
             * thing to do when an error is detected is to call `g_error()`.
             * @param filename the name of the file to parse
             * @returns %TRUE on success, %FALSE if an error occurred
             */
            add_from_file(filename: string): boolean;
            /**
             * Parses a resource file containing a UI definition
             * and merges it with the current contents of `builder`.
             *
             * This function is useful if you need to call
             * [method`Gtk`.Builder.set_current_object] to add user data to
             * callbacks before loading GtkBuilder UI. Otherwise, you probably
             * want [ctor`Gtk`.Builder.new_from_resource] instead.
             *
             * If an error occurs, 0 will be returned and `error` will be assigned a
             * `GError` from the %GTK_BUILDER_ERROR, %G_MARKUP_ERROR or %G_RESOURCE_ERROR
             * domain.
             *
             * It’s not really reasonable to attempt to handle failures of this
             * call.  The only reasonable thing to do when an error is detected is
             * to call g_error().
             * @param resource_path the path of the resource file to parse
             * @returns %TRUE on success, %FALSE if an error occurred
             */
            add_from_resource(resource_path: string): boolean;
            /**
             * Parses a string containing a UI definition and merges it
             * with the current contents of `builder`.
             *
             * This function is useful if you need to call
             * [method`Gtk`.Builder.set_current_object] to add user data to
             * callbacks before loading `GtkBuilder` UI. Otherwise, you probably
             * want [ctor`Gtk`.Builder.new_from_string] instead.
             *
             * Upon errors %FALSE will be returned and `error` will be assigned a
             * `GError` from the %GTK_BUILDER_ERROR, %G_MARKUP_ERROR or
             * %G_VARIANT_PARSE_ERROR domain.
             *
             * It’s not really reasonable to attempt to handle failures of this
             * call.  The only reasonable thing to do when an error is detected is
             * to call g_error().
             * @param buffer the string to parse
             * @param length the length of @buffer (may be -1 if @buffer is nul-terminated)
             * @returns %TRUE on success, %FALSE if an error occurred
             */
            add_from_string(buffer: string, length: number): boolean;
            /**
             * Parses a file containing a UI definition building only the
             * requested objects and merges them with the current contents
             * of `builder`.
             *
             * Upon errors, 0 will be returned and `error` will be assigned a
             * `GError` from the %GTK_BUILDER_ERROR, %G_MARKUP_ERROR or %G_FILE_ERROR
             * domain.
             *
             * If you are adding an object that depends on an object that is not
             * its child (for instance a `GtkTreeView` that depends on its
             * `GtkTreeModel`), you have to explicitly list all of them in `object_ids`.
             * @param filename the name of the file to parse
             * @param object_ids nul-terminated array of objects to build
             * @returns %TRUE on success, %FALSE if an error occurred
             */
            add_objects_from_file(filename: string, object_ids: string[]): boolean;
            /**
             * Parses a resource file containing a UI definition, building
             * only the requested objects and merges them with the current
             * contents of `builder`.
             *
             * Upon errors, 0 will be returned and `error` will be assigned a
             * `GError` from the %GTK_BUILDER_ERROR, %G_MARKUP_ERROR or %G_RESOURCE_ERROR
             * domain.
             *
             * If you are adding an object that depends on an object that is not
             * its child (for instance a `GtkTreeView` that depends on its
             * `GtkTreeModel`), you have to explicitly list all of them in `object_ids`.
             * @param resource_path the path of the resource file to parse
             * @param object_ids nul-terminated array of objects to build
             * @returns %TRUE on success, %FALSE if an error occurred
             */
            add_objects_from_resource(resource_path: string, object_ids: string[]): boolean;
            /**
             * Parses a string containing a UI definition, building only the
             * requested objects and merges them with the current contents of
             * `builder`.
             *
             * Upon errors %FALSE will be returned and `error` will be assigned a
             * `GError` from the %GTK_BUILDER_ERROR or %G_MARKUP_ERROR domain.
             *
             * If you are adding an object that depends on an object that is not
             * its child (for instance a `GtkTreeView` that depends on its
             * `GtkTreeModel`), you have to explicitly list all of them in `object_ids`.
             * @param buffer the string to parse
             * @param length the length of @buffer (may be -1 if @buffer is nul-terminated)
             * @param object_ids nul-terminated array of objects to build
             * @returns %TRUE on success, %FALSE if an error occurred
             */
            add_objects_from_string(buffer: string, length: number, object_ids: string[]): boolean;
            /**
             * Creates a closure to invoke the function called `function_name`.
             *
             * This is using the create_closure() implementation of `builder'`s
             * [iface`Gtk`.BuilderScope].
             *
             * If no closure could be created, %NULL will be returned and `error`
             * will be set.
             * @param function_name name of the function to look up
             * @param flags closure creation flags
             * @param object Object to create the closure with
             * @returns A new closure for invoking @function_name
             */
            create_closure(
                function_name: string,
                flags: BuilderClosureFlags | null,
                object?: GObject.Object | null,
            ): GObject.Closure | null;
            /**
             * Add `object` to the `builder` object pool so it can be
             * referenced just like any other object built by builder.
             *
             * Only a single object may be added using `name`. However,
             * it is not an error to expose the same object under multiple
             * names. `gtk_builder_get_object()` may be used to determine
             * if an object has already been added with `name`.
             * @param name the name of the object exposed to the builder
             * @param object the object to expose
             */
            expose_object(name: string, object: GObject.Object): void;
            /**
             * Main private entry point for building composite components
             * from template XML.
             *
             * Most likely you do not need to call this function in applications as
             * templates are handled by `GtkWidget`.
             * @param object the object that is being extended
             * @param template_type the type that the template is for
             * @param buffer the string to parse
             * @param length the length of @buffer (may be -1 if @buffer is nul-terminated)
             * @returns A positive value on success, 0 if an error occurred
             */
            extend_with_template(
                object: GObject.Object,
                template_type: GObject.GType,
                buffer: string,
                length: number,
            ): boolean;
            /**
             * Gets the current object set via gtk_builder_set_current_object().
             * @returns the current object
             */
            get_current_object<T = GObject.Object>(): T;
            /**
             * Gets the object named `name`.
             *
             * Note that this function does not increment the reference count
             * of the returned object.
             * @param name name of object to get
             * @returns the object named @name
             */
            get_object<T = GObject.Object>(name: string): T;
            /**
             * Gets all objects that have been constructed by `builder`.
             *
             * Note that this function does not increment the reference
             * counts of the returned objects.
             * @returns a   newly-allocated `GSList` containing all the objects   constructed by the `GtkBuilder instance`. It should be   freed by g_slist_free()
             */
            get_objects(): GObject.Object[];
            /**
             * Gets the scope in use that was set via gtk_builder_set_scope().
             * @returns the current scope
             */
            get_scope(): BuilderScope;
            /**
             * Gets the translation domain of `builder`.
             * @returns the translation domain
             */
            get_translation_domain(): string | null;
            /**
             * Looks up a type by name.
             *
             * This is using the virtual function that `GtkBuilder` has
             * for that purpose. This is mainly used when implementing
             * the `GtkBuildable` interface on a type.
             * @param type_name type name to lookup
             * @returns the `GType` found for @type_name or %G_TYPE_INVALID   if no type was found
             */
            get_type_from_name(type_name: string): GObject.GType;
            /**
             * Sets the current object for the `builder`.
             *
             * The current object can be thought of as the `this` object that the
             * builder is working for and will often be used as the default object
             * when an object is optional.
             *
             * [method`Gtk`.Widget.init_template] for example will set the current
             * object to the widget the template is inited for. For functions like
             * [ctor`Gtk`.Builder.new_from_resource], the current object will be %NULL.
             * @param current_object the new current object
             */
            set_current_object(current_object?: GObject.Object | null): void;
            /**
             * Sets the scope the builder should operate in.
             *
             * If `scope` is %NULL, a new [class`Gtk`.BuilderCScope] will be created.
             * @param scope the scope to use
             */
            set_scope(scope?: BuilderScope | null): void;
            /**
             * Sets the translation domain of `builder`.
             * @param domain the translation domain
             */
            set_translation_domain(domain?: string | null): void;
            /**
             * Demarshals a value from a string.
             *
             * This function calls g_value_init() on the `value` argument,
             * so it need not be initialised beforehand.
             *
             * Can handle char, uchar, boolean, int, uint, long,
             * ulong, enum, flags, float, double, string, `GdkRGBA` and
             * `GtkAdjustment` type values.
             *
             * Upon errors %FALSE will be returned and `error` will be
             * assigned a `GError` from the %GTK_BUILDER_ERROR domain.
             * @param pspec the `GParamSpec` for the property
             * @param string the string representation of the value
             * @returns %TRUE on success
             */
            value_from_string(pspec: GObject.ParamSpec, string: string): [boolean, unknown];
            /**
             * Demarshals a value from a string.
             *
             * Unlike [method`Gtk`.Builder.value_from_string], this function
             * takes a `GType` instead of `GParamSpec`.
             *
             * Calls g_value_init() on the `value` argument, so it
             * need not be initialised beforehand.
             *
             * Upon errors %FALSE will be returned and `error` will be
             * assigned a `GError` from the %GTK_BUILDER_ERROR domain.
             * @param type the `GType` of the value
             * @param string the string representation of the value
             * @returns %TRUE on success
             */
            value_from_string_type(type: GObject.GType, string: string): [boolean, unknown];
        }

        namespace BuilderCScope {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps, BuilderScope.ConstructorProps {}
        }

        /**
         * A `GtkBuilderScope` implementation for the C language.
         *
         * `GtkBuilderCScope` instances use symbols explicitly added to `builder`
         * with prior calls to [method`Gtk`.BuilderCScope.add_callback_symbol].
         * If developers want to do that, they are encouraged to create their
         * own scopes for that purpose.
         *
         * In the case that symbols are not explicitly added; GTK will uses
         * `GModule`’s introspective features (by opening the module %NULL) to
         * look at the application’s symbol table. From here it tries to match
         * the signal function names given in the interface description with
         * symbols in the application.
         *
         * Note that unless [method`Gtk`.BuilderCScope.add_callback_symbol] is
         * called for all signal callbacks which are referenced by the loaded XML,
         * this functionality will require that `GModule` be supported on the platform.
         */
        class BuilderCScope extends GObject.Object implements BuilderScope {
            static $gtype: GObject.GType<BuilderCScope>;

            // Constructors

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

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

            static ['new'](): BuilderCScope;

            // Methods

            /**
             * Adds the `callback_symbol` to the scope of `builder` under the
             * given `callback_name`.
             *
             * Using this function overrides the behavior of
             * [method`Gtk`.Builder.create_closure] for any callback symbols that
             * are added. Using this method allows for better encapsulation as it
             * does not require that callback symbols be declared in the global
             * namespace.
             * @param callback_name The name of the callback, as expected in the XML
             * @param callback_symbol The callback pointer
             */
            add_callback_symbol(callback_name: string, callback_symbol: GObject.Callback): void;

            // Inherited methods
            /**
             * Create a closure with the given arguments. See gtk_builder_create_closure()
             *   for more details on those.
             *   The C implementation will try to use dlsym() to locate the function name and then
             *   g_cclosure_new() to create a closure for the symbol.
             *   The default implementation just fails and returns %NULL.
             * @param builder
             * @param function_name
             * @param flags
             * @param object
             */
            vfunc_create_closure(
                builder: Builder,
                function_name: string,
                flags: BuilderClosureFlags,
                object: GObject.Object,
            ): GObject.Closure;
            /**
             * Try to lookup a `GType` via the given function name, specified
             *   explicitly in a GtkBuilder file, like via the "type-func" attribute in the `<object>` tag.
             *   This function is very rarely used.
             *   The C implementation will use dlsym() and call the resulting function as a `GTypeFunc`.
             *   The default implementation will fail and just return %G_TYPE_INVALID.
             * @param builder
             * @param function_name
             */
            vfunc_get_type_from_function(builder: Builder, function_name: string): GObject.GType;
            /**
             * Try to lookup a `GType` via the its name. See
             *   gtk_builder_get_type_from_name() for more details.
             *   The C implementation will use g_type_from_name() and if that fails try to guess the
             *   correct function name for registering the type and then use dlsym() to load it.
             *   The default implementation just tries g_type_from_name() and otherwise fails.
             * @param builder
             * @param type_name
             */
            vfunc_get_type_from_name(builder: Builder, type_name: string): GObject.GType;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace BuilderListItemFactory {
            // Constructor properties interface

            interface ConstructorProps extends ListItemFactory.ConstructorProps {
                bytes: GLib.Bytes;
                resource: string;
                scope: BuilderScope;
            }
        }

        /**
         * `GtkBuilderListItemFactory` is a `GtkListItemFactory` that creates
         * widgets by instantiating `GtkBuilder` UI templates.
         *
         * The templates must extend the class that the parent widget expects.
         * For example, a factory provided to [property`Gtk`.ListView:factory] must have
         * a template that extends [class`Gtk`.ListItem].
         *
         * Templates typically use `GtkExpression`s to obtain data from the items
         * in the model.
         *
         * Example:
         * ```xml
         *   <interface>
         *     <template class="GtkListItem">
         *       <property name="child">
         *         <object class="GtkLabel">
         *           <property name="xalign">0</property>
         *           <binding name="label">
         *             <lookup name="name" type="SettingsKey">
         *               <lookup name="item">GtkListItem</lookup>
         *             </lookup>
         *           </binding>
         *         </object>
         *       </property>
         *     </template>
         *   </interface>
         * ```
         */
        class BuilderListItemFactory extends ListItemFactory {
            static $gtype: GObject.GType<BuilderListItemFactory>;

            // Properties

            /**
             * `GBytes` containing the UI definition.
             */
            get bytes(): GLib.Bytes;
            /**
             * Path of the resource containing the UI definition.
             */
            get resource(): string;
            /**
             * `GtkBuilderScope` to use when instantiating listitems
             */
            get scope(): BuilderScope;

            // Constructors

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

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

            static new_from_bytes(scope: BuilderScope | null, bytes: GLib.Bytes | Uint8Array): BuilderListItemFactory;

            static new_from_resource(scope: BuilderScope | null, resource_path: string): BuilderListItemFactory;

            // Methods

            /**
             * Gets the data used as the `GtkBuilder` UI template for constructing
             * listitems.
             * @returns The `GtkBuilder` data
             */
            get_bytes(): GLib.Bytes;
            /**
             * If the data references a resource, gets the path of that resource.
             * @returns The path to the resource
             */
            get_resource(): string | null;
            /**
             * Gets the scope used when constructing listitems.
             * @returns The scope used when constructing listitems
             */
            get_scope(): BuilderScope | null;
        }

        namespace Button {
            // Signal callback interfaces

            interface Activate {
                (): void;
            }

            interface Clicked {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Actionable.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                can_shrink: boolean;
                canShrink: boolean;
                child: Widget;
                has_frame: boolean;
                hasFrame: boolean;
                icon_name: string;
                iconName: string;
                label: string;
                use_underline: boolean;
                useUnderline: boolean;
            }
        }

        /**
         * The `GtkButton` widget is generally used to trigger a callback function that is
         * called when the button is pressed.
         *
         * ![An example GtkButton](button.png)
         *
         * The `GtkButton` widget can hold any valid child widget. That is, it can hold
         * almost any other standard `GtkWidget`. The most commonly used child is the
         * `GtkLabel`.
         *
         * # Shortcuts and Gestures
         *
         * The following signals have default keybindings:
         *
         * - [signal`Gtk`.Button::activate]
         *
         * # CSS nodes
         *
         * `GtkButton` has a single CSS node with name button. The node will get the
         * style classes .image-button or .text-button, if the content is just an
         * image or label, respectively. It may also receive the .flat style class.
         * When activating a button via the keyboard, the button will temporarily
         * gain the .keyboard-activating style class.
         *
         * Other style classes that are commonly used with `GtkButton` include
         * .suggested-action and .destructive-action. In special cases, buttons
         * can be made round by adding the .circular style class.
         *
         * Button-like widgets like [class`Gtk`.ToggleButton], [class`Gtk`.MenuButton],
         * [class`Gtk`.VolumeButton], [class`Gtk`.LockButton], [class`Gtk`.ColorButton]
         * or [class`Gtk`.FontButton] use style classes such as .toggle, .popup, .scale,
         * .lock, .color on the button node to differentiate themselves from a plain
         * `GtkButton`.
         *
         * # Accessibility
         *
         * `GtkButton` uses the %GTK_ACCESSIBLE_ROLE_BUTTON role.
         */
        class Button extends Widget implements Accessible, Actionable, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<Button>;

            // Properties

            /**
             * Whether the size of the button can be made smaller than the natural
             * size of its contents.
             *
             * For text buttons, setting this property will allow ellipsizing the label.
             *
             * If the contents of a button are an icon or a custom widget, setting this
             * property has no effect.
             */
            get can_shrink(): boolean;
            set can_shrink(val: boolean);
            /**
             * Whether the size of the button can be made smaller than the natural
             * size of its contents.
             *
             * For text buttons, setting this property will allow ellipsizing the label.
             *
             * If the contents of a button are an icon or a custom widget, setting this
             * property has no effect.
             */
            get canShrink(): boolean;
            set canShrink(val: boolean);
            /**
             * The child widget.
             */
            get child(): Widget;
            set child(val: Widget);
            /**
             * Whether the button has a frame.
             */
            get has_frame(): boolean;
            set has_frame(val: boolean);
            /**
             * Whether the button has a frame.
             */
            get hasFrame(): boolean;
            set hasFrame(val: boolean);
            /**
             * The name of the icon used to automatically populate the button.
             */
            get icon_name(): string;
            set icon_name(val: string);
            /**
             * The name of the icon used to automatically populate the button.
             */
            get iconName(): string;
            set iconName(val: string);
            /**
             * Text of the label inside the button, if the button contains a label widget.
             */
            get label(): string;
            set label(val: string);
            /**
             * If set, an underline in the text indicates that the following character is
             * to be used as mnemonic.
             */
            get use_underline(): boolean;
            set use_underline(val: boolean);
            /**
             * If set, an underline in the text indicates that the following character is
             * to be used as mnemonic.
             */
            get useUnderline(): boolean;
            set useUnderline(val: boolean);

            // Constructors

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

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

            static ['new'](): Button;

            static new_from_icon_name(icon_name: string): Button;

            static new_with_label(label: string): Button;

            static new_with_mnemonic(label: string): Button;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate', callback: (_source: this) => void): number;
            connect_after(signal: 'activate', callback: (_source: this) => void): number;
            emit(signal: 'activate'): void;
            connect(signal: 'clicked', callback: (_source: this) => void): number;
            connect_after(signal: 'clicked', callback: (_source: this) => void): number;
            emit(signal: 'clicked'): void;

            // Virtual methods

            /**
             * Signal that causes the button to animate press then
             *    release. Applications should never connect to this signal, but use
             *    the `clicked` signal.
             */
            vfunc_activate(): void;
            /**
             * Signal emitted when the button has been activated (pressed and released).
             */
            vfunc_clicked(): void;

            // Methods

            /**
             * Retrieves whether the button can be smaller than the natural
             * size of its contents.
             * @returns true if the button can shrink, and false otherwise
             */
            get_can_shrink(): boolean;
            /**
             * Gets the child widget of `button`.
             * @returns the child widget of @button
             */
            get_child(): Widget | null;
            /**
             * Returns whether the button has a frame.
             * @returns %TRUE if the button has a frame
             */
            get_has_frame(): boolean;
            /**
             * Returns the icon name of the button.
             *
             * If the icon name has not been set with [method`Gtk`.Button.set_icon_name]
             * the return value will be %NULL. This will be the case if you create
             * an empty button with [ctor`Gtk`.Button.new] to use as a container.
             * @returns The icon name set via [method@Gtk.Button.set_icon_name]
             */
            get_icon_name(): string | null;
            /**
             * Fetches the text from the label of the button.
             *
             * If the label text has not been set with [method`Gtk`.Button.set_label]
             * the return value will be %NULL. This will be the case if you create
             * an empty button with [ctor`Gtk`.Button.new] to use as a container.
             * @returns The text of the label widget. This string is owned by the widget and must not be modified or freed.
             */
            get_label(): string | null;
            /**
             * gets whether underlines are interpreted as mnemonics.
             *
             * See [method`Gtk`.Button.set_use_underline].
             * @returns %TRUE if an embedded underline in the button label   indicates the mnemonic accelerator keys.
             */
            get_use_underline(): boolean;
            /**
             * Sets whether the button size can be smaller than the natural size of
             * its contents.
             *
             * For text buttons, setting `can_shrink` to true will ellipsize the label.
             *
             * For icons and custom children, this function has no effect.
             * @param can_shrink whether the button can shrink
             */
            set_can_shrink(can_shrink: boolean): void;
            /**
             * Sets the child widget of `button`.
             *
             * Note that by using this API, you take full responsibility for setting
             * up the proper accessibility label and description information for `button`.
             * Most likely, you'll either set the accessibility label or description
             * for `button` explicitly, or you'll set a labelled-by or described-by
             * relations from `child` to `button`.
             * @param child the child widget
             */
            set_child(child?: Widget | null): void;
            /**
             * Sets the style of the button.
             *
             * Buttons can have a flat appearance or have a frame drawn around them.
             * @param has_frame whether the button should have a visible frame
             */
            set_has_frame(has_frame: boolean): void;
            /**
             * Adds a `GtkImage` with the given icon name as a child.
             *
             * If `button` already contains a child widget, that child widget will
             * be removed and replaced with the image.
             * @param icon_name An icon name
             */
            set_icon_name(icon_name: string): void;
            /**
             * Sets the text of the label of the button to `label`.
             *
             * This will also clear any previously set labels.
             * @param label a string
             */
            set_label(label: string): void;
            /**
             * Sets whether to use underlines as mnemonics.
             *
             * If true, an underline in the text of the button label indicates
             * the next character should be used for the mnemonic accelerator key.
             * @param use_underline %TRUE if underlines in the text indicate mnemonics
             */
            set_use_underline(use_underline: boolean): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The name of the action with which this widget should be associated.
             */
            get action_name(): string;
            set action_name(val: string);
            /**
             * The name of the action with which this widget should be associated.
             */
            get actionName(): string;
            set actionName(val: string);
            /**
             * The target value of the actionable widget's action.
             */
            get action_target(): GLib.Variant;
            set action_target(val: GLib.Variant);
            /**
             * The target value of the actionable widget's action.
             */
            get actionTarget(): GLib.Variant;
            set actionTarget(val: GLib.Variant);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the action name for `actionable`.
             * @returns the action name
             */
            get_action_name(): string | null;
            /**
             * Gets the current target value of `actionable`.
             * @returns the current target value
             */
            get_action_target_value(): GLib.Variant | null;
            /**
             * Specifies the name of the action with which this widget should be
             * associated.
             *
             * If `action_name` is %NULL then the widget will be unassociated from
             * any previous action.
             *
             * Usually this function is used when the widget is located (or will be
             * located) within the hierarchy of a `GtkApplicationWindow`.
             *
             * Names are of the form “win.save” or “app.quit” for actions on the
             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
             * associated with the window.
             * @param action_name an action name
             */
            set_action_name(action_name?: string | null): void;
            /**
             * Sets the target value of an actionable widget.
             *
             * If `target_value` is %NULL then the target value is unset.
             *
             * The target value has two purposes. First, it is used as the parameter
             * to activation of the action associated with the `GtkActionable` widget.
             * Second, it is used to determine if the widget should be rendered as
             * “active” — the widget is active if the state is equal to the given target.
             *
             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
             * with string state in a typical “radio button” situation. Each button
             * will be associated with the same action, but with a different target
             * value for that action. Clicking on a particular button will activate
             * the action with the target of that button, which will typically cause
             * the action’s state to change to that value. Since the action’s state
             * is now equal to the target value of the button, the button will now
             * be rendered as active (and the other buttons, with different targets,
             * rendered inactive).
             * @param target_value a [struct@GLib.Variant] to set as the target value
             */
            set_action_target_value(target_value?: GLib.Variant | null): void;
            /**
             * Sets the action-name and associated string target value of an
             * actionable widget.
             *
             * `detailed_action_name` is a string in the format accepted by
             * [func`Gio`.Action.parse_detailed_name].
             * @param detailed_action_name the detailed action name
             */
            set_detailed_action_name(detailed_action_name: string): void;
            /**
             * Gets the action name for `actionable`.
             */
            vfunc_get_action_name(): string | null;
            /**
             * Gets the current target value of `actionable`.
             */
            vfunc_get_action_target_value(): GLib.Variant | null;
            /**
             * Specifies the name of the action with which this widget should be
             * associated.
             *
             * If `action_name` is %NULL then the widget will be unassociated from
             * any previous action.
             *
             * Usually this function is used when the widget is located (or will be
             * located) within the hierarchy of a `GtkApplicationWindow`.
             *
             * Names are of the form “win.save” or “app.quit” for actions on the
             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
             * associated with the window.
             * @param action_name an action name
             */
            vfunc_set_action_name(action_name?: string | null): void;
            /**
             * Sets the target value of an actionable widget.
             *
             * If `target_value` is %NULL then the target value is unset.
             *
             * The target value has two purposes. First, it is used as the parameter
             * to activation of the action associated with the `GtkActionable` widget.
             * Second, it is used to determine if the widget should be rendered as
             * “active” — the widget is active if the state is equal to the given target.
             *
             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
             * with string state in a typical “radio button” situation. Each button
             * will be associated with the same action, but with a different target
             * value for that action. Clicking on a particular button will activate
             * the action with the target of that button, which will typically cause
             * the action’s state to change to that value. Since the action’s state
             * is now equal to the target value of the button, the button will now
             * be rendered as active (and the other buttons, with different targets,
             * rendered inactive).
             * @param target_value a [struct@GLib.Variant] to set as the target value
             */
            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        /**
         * A variant of `GtkClosureExpression` using a C closure.
         */
        class CClosureExpression extends Expression {
            static $gtype: GObject.GType<CClosureExpression>;

            // Constructors

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

            static ['new'](
                value_type: GObject.GType,
                marshal: GObject.ClosureMarshal | null,
                params: Expression[],
                callback_func: GObject.Callback,
                user_destroy?: GObject.ClosureNotify | null,
            ): CClosureExpression;
        }

        namespace Calendar {
            // Signal callback interfaces

            interface DaySelected {
                (): void;
            }

            interface NextMonth {
                (): void;
            }

            interface NextYear {
                (): void;
            }

            interface PrevMonth {
                (): void;
            }

            interface PrevYear {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                day: number;
                month: number;
                show_day_names: boolean;
                showDayNames: boolean;
                show_heading: boolean;
                showHeading: boolean;
                show_week_numbers: boolean;
                showWeekNumbers: boolean;
                year: number;
            }
        }

        /**
         * `GtkCalendar` is a widget that displays a Gregorian calendar, one month
         * at a time.
         *
         * ![An example GtkCalendar](calendar.png)
         *
         * A `GtkCalendar` can be created with [ctor`Gtk`.Calendar.new].
         *
         * The date that is currently displayed can be altered with
         * [method`Gtk`.Calendar.select_day].
         *
         * To place a visual marker on a particular day, use
         * [method`Gtk`.Calendar.mark_day] and to remove the marker,
         * [method`Gtk`.Calendar.unmark_day]. Alternative, all
         * marks can be cleared with [method`Gtk`.Calendar.clear_marks].
         *
         * The selected date can be retrieved from a `GtkCalendar` using
         * [method`Gtk`.Calendar.get_date].
         *
         * Users should be aware that, although the Gregorian calendar is the
         * legal calendar in most countries, it was adopted progressively
         * between 1582 and 1929. Display before these dates is likely to be
         * historically incorrect.
         *
         * # Shortcuts and Gestures
         *
         * `GtkCalendar` supports the following gestures:
         *
         * - Scrolling up or down will switch to the previous or next month.
         * - Date strings can be dropped for setting the current day.
         *
         * # CSS nodes
         *
         * ```
         * calendar.view
         * ├── header
         * │   ├── button
         * │   ├── stack.month
         * │   ├── button
         * │   ├── button
         * │   ├── label.year
         * │   ╰── button
         * ╰── grid
         *     ╰── label[.day-name][.week-number][.day-number][.other-month][.today]
         * ```
         *
         * `GtkCalendar` has a main node with name calendar. It contains a subnode
         * called header containing the widgets for switching between years and months.
         *
         * The grid subnode contains all day labels, including week numbers on the left
         * (marked with the .week-number css class) and day names on top (marked with the
         * .day-name css class).
         *
         * Day labels that belong to the previous or next month get the .other-month
         * style class. The label of the current day get the .today style class.
         *
         * Marked day labels get the :selected state assigned.
         */
        class Calendar extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<Calendar>;

            // Properties

            /**
             * The selected day (as a number between 1 and 31).
             */
            get day(): number;
            set day(val: number);
            /**
             * The selected month (as a number between 0 and 11).
             *
             * This property gets initially set to the current month.
             */
            get month(): number;
            set month(val: number);
            /**
             * Determines whether day names are displayed.
             */
            get show_day_names(): boolean;
            set show_day_names(val: boolean);
            /**
             * Determines whether day names are displayed.
             */
            get showDayNames(): boolean;
            set showDayNames(val: boolean);
            /**
             * Determines whether a heading is displayed.
             */
            get show_heading(): boolean;
            set show_heading(val: boolean);
            /**
             * Determines whether a heading is displayed.
             */
            get showHeading(): boolean;
            set showHeading(val: boolean);
            /**
             * Determines whether week numbers are displayed.
             */
            get show_week_numbers(): boolean;
            set show_week_numbers(val: boolean);
            /**
             * Determines whether week numbers are displayed.
             */
            get showWeekNumbers(): boolean;
            set showWeekNumbers(val: boolean);
            /**
             * The selected year.
             *
             * This property gets initially set to the current year.
             */
            get year(): number;
            set year(val: number);

            // Constructors

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

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

            static ['new'](): Calendar;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'day-selected', callback: (_source: this) => void): number;
            connect_after(signal: 'day-selected', callback: (_source: this) => void): number;
            emit(signal: 'day-selected'): void;
            connect(signal: 'next-month', callback: (_source: this) => void): number;
            connect_after(signal: 'next-month', callback: (_source: this) => void): number;
            emit(signal: 'next-month'): void;
            connect(signal: 'next-year', callback: (_source: this) => void): number;
            connect_after(signal: 'next-year', callback: (_source: this) => void): number;
            emit(signal: 'next-year'): void;
            connect(signal: 'prev-month', callback: (_source: this) => void): number;
            connect_after(signal: 'prev-month', callback: (_source: this) => void): number;
            emit(signal: 'prev-month'): void;
            connect(signal: 'prev-year', callback: (_source: this) => void): number;
            connect_after(signal: 'prev-year', callback: (_source: this) => void): number;
            emit(signal: 'prev-year'): void;

            // Methods

            /**
             * Remove all visual markers.
             */
            clear_marks(): void;
            /**
             * Returns a `GDateTime` representing the shown
             * year, month and the selected day.
             *
             * The returned date is in the local time zone.
             * @returns the `GDateTime` representing the shown date
             */
            get_date(): GLib.DateTime;
            /**
             * Gets the day of the selected date.
             * @returns the day of the selected date.
             */
            get_day(): number;
            /**
             * Returns if the `day` of the `calendar` is already marked.
             * @param day the day number between 1 and 31.
             * @returns whether the day is marked.
             */
            get_day_is_marked(day: number): boolean;
            /**
             * Gets the month of the selected date.
             * @returns The month of the selected date (as a number between 0 and 11).
             */
            get_month(): number;
            /**
             * Returns whether `self` is currently showing the names
             * of the week days.
             *
             * This is the value of the [property`Gtk`.Calendar:show-day-names]
             * property.
             * @returns Whether the calendar shows day names.
             */
            get_show_day_names(): boolean;
            /**
             * Returns whether `self` is currently showing the heading.
             *
             * This is the value of the [property`Gtk`.Calendar:show-heading]
             * property.
             * @returns Whether the calendar is showing a heading.
             */
            get_show_heading(): boolean;
            /**
             * Returns whether `self` is showing week numbers right
             * now.
             *
             * This is the value of the [property`Gtk`.Calendar:show-week-numbers]
             * property.
             * @returns Whether the calendar is showing week numbers.
             */
            get_show_week_numbers(): boolean;
            /**
             * Gets the year of the selected date.
             * @returns the year of the selected date.
             */
            get_year(): number;
            /**
             * Places a visual marker on a particular day of the current month.
             * @param day the day number to mark between 1 and 31.
             */
            mark_day(day: number): void;
            /**
             * Switches to `date'`s year and month and select its day.
             * @param date a `GDateTime` representing the day to select
             */
            select_day(date: GLib.DateTime): void;
            /**
             * Sets the day for the selected date.
             *
             * The new date must be valid. For example, setting 31 for the day when the
             * month is February, fails.
             * @param day The desired day for the selected date (as a number between 1 and 31).
             */
            set_day(day: number): void;
            /**
             * Sets the month for the selected date.
             *
             * The new date must be valid. For example, setting 1 (February) for the month
             * when the day is 31, fails.
             * @param month The desired month for the selected date (as a number between 0 and 11).
             */
            set_month(month: number): void;
            /**
             * Sets whether the calendar shows day names.
             * @param value Whether to show day names above the day numbers
             */
            set_show_day_names(value: boolean): void;
            /**
             * Sets whether the calendar should show a heading.
             *
             * The heading contains the current year and month as well as
             * buttons for changing both.
             * @param value Whether to show the heading in the calendar
             */
            set_show_heading(value: boolean): void;
            /**
             * Sets whether week numbers are shown in the calendar.
             * @param value whether to show week numbers on the left of the days
             */
            set_show_week_numbers(value: boolean): void;
            /**
             * Sets the year for the selected date.
             *
             * The new date must be valid. For example, setting 2023 for the year when then
             * the date is 2024-02-29, fails.
             * @param year The desired year for the selected date (within [struct@GLib.DateTime]   limits, i.e. from 0001 to 9999).
             */
            set_year(year: number): void;
            /**
             * Removes the visual marker from a particular day.
             * @param day the day number to unmark between 1 and 31.
             */
            unmark_day(day: number): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace CallbackAction {
            // Constructor properties interface

            interface ConstructorProps extends ShortcutAction.ConstructorProps {}
        }

        /**
         * A `GtkShortcutAction` that invokes a callback.
         */
        class CallbackAction extends ShortcutAction {
            static $gtype: GObject.GType<CallbackAction>;

            // Constructors

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

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

            static ['new'](callback: ShortcutFunc): CallbackAction;
        }

        namespace CellArea {
            // Signal callback interfaces

            interface AddEditable {
                (renderer: CellRenderer, editable: CellEditable, cell_area: Gdk.Rectangle, path: string): void;
            }

            interface ApplyAttributes {
                (model: TreeModel, iter: TreeIter, is_expander: boolean, is_expanded: boolean): void;
            }

            interface FocusChanged {
                (renderer: CellRenderer, path: string): void;
            }

            interface RemoveEditable {
                (renderer: CellRenderer, editable: CellEditable): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends GObject.InitiallyUnowned.ConstructorProps,
                    Buildable.ConstructorProps,
                    CellLayout.ConstructorProps {
                edit_widget: CellEditable;
                editWidget: CellEditable;
                edited_cell: CellRenderer;
                editedCell: CellRenderer;
                focus_cell: CellRenderer;
                focusCell: CellRenderer;
            }
        }

        /**
         * An abstract class for laying out `GtkCellRenderer`s
         *
         * The `GtkCellArea` is an abstract class for [iface`Gtk`.CellLayout]
         * widgets (also referred to as "layouting widgets") to interface with
         * an arbitrary number of [class`Gtk`.CellRenderer]s and interact with the user
         * for a given [iface`Gtk`.TreeModel] row.
         *
         * The cell area handles events, focus navigation, drawing and
         * size requests and allocations for a given row of data.
         *
         * Usually users dont have to interact with the `GtkCellArea` directly
         * unless they are implementing a cell-layouting widget themselves.
         *
         * ## Requesting area sizes
         *
         * As outlined in
         * [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management),
         * GTK uses a height-for-width
         * geometry management system to compute the sizes of widgets and user
         * interfaces. `GtkCellArea` uses the same semantics to calculate the
         * size of an area for an arbitrary number of `GtkTreeModel` rows.
         *
         * When requesting the size of a cell area one needs to calculate
         * the size for a handful of rows, and this will be done differently by
         * different layouting widgets. For instance a [class`Gtk`.TreeViewColumn]
         * always lines up the areas from top to bottom while a [class`Gtk`.IconView]
         * on the other hand might enforce that all areas received the same
         * width and wrap the areas around, requesting height for more cell
         * areas when allocated less width.
         *
         * It’s also important for areas to maintain some cell
         * alignments with areas rendered for adjacent rows (cells can
         * appear “columnized” inside an area even when the size of
         * cells are different in each row). For this reason the `GtkCellArea`
         * uses a [class`Gtk`.CellAreaContext] object to store the alignments
         * and sizes along the way (as well as the overall largest minimum
         * and natural size for all the rows which have been calculated
         * with the said context).
         *
         * The [class`Gtk`.CellAreaContext] is an opaque object specific to the
         * `GtkCellArea` which created it (see [method`Gtk`.CellArea.create_context]).
         *
         * The owning cell-layouting widget can create as many contexts as
         * it wishes to calculate sizes of rows which should receive the
         * same size in at least one orientation (horizontally or vertically),
         * However, it’s important that the same [class`Gtk`.CellAreaContext] which
         * was used to request the sizes for a given `GtkTreeModel` row be
         * used when rendering or processing events for that row.
         *
         * In order to request the width of all the rows at the root level
         * of a `GtkTreeModel` one would do the following:
         *
         * ```c
         * GtkTreeIter iter;
         * int minimum_width;
         * int natural_width;
         *
         * valid = gtk_tree_model_get_iter_first (model, &iter);
         * while (valid)
         *   {
         *     gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
         *     gtk_cell_area_get_preferred_width (area, context, widget, NULL, NULL);
         *
         *     valid = gtk_tree_model_iter_next (model, &iter);
         *   }
         *
         * gtk_cell_area_context_get_preferred_width (context, &minimum_width, &natural_width);
         * ```
         *
         * Note that in this example it’s not important to observe the
         * returned minimum and natural width of the area for each row
         * unless the cell-layouting object is actually interested in the
         * widths of individual rows. The overall width is however stored
         * in the accompanying `GtkCellAreaContext` object and can be consulted
         * at any time.
         *
         * This can be useful since `GtkCellLayout` widgets usually have to
         * support requesting and rendering rows in treemodels with an
         * exceedingly large amount of rows. The `GtkCellLayout` widget in
         * that case would calculate the required width of the rows in an
         * idle or timeout source (see [func`GLib`.timeout_add]) and when the widget
         * is requested its actual width in [vfunc`Gtk`.Widget.measure]
         * it can simply consult the width accumulated so far in the
         * `GtkCellAreaContext` object.
         *
         * A simple example where rows are rendered from top to bottom and
         * take up the full width of the layouting widget would look like:
         *
         * ```c
         * static void
         * foo_get_preferred_width (GtkWidget *widget,
         *                          int       *minimum_size,
         *                          int       *natural_size)
         * {
         *   Foo *self = FOO (widget);
         *   FooPrivate *priv = foo_get_instance_private (self);
         *
         *   foo_ensure_at_least_one_handfull_of_rows_have_been_requested (self);
         *
         *   gtk_cell_area_context_get_preferred_width (priv->context, minimum_size, natural_size);
         * }
         * ```
         *
         * In the above example the `Foo` widget has to make sure that some
         * row sizes have been calculated (the amount of rows that `Foo` judged
         * was appropriate to request space for in a single timeout iteration)
         * before simply returning the amount of space required by the area via
         * the `GtkCellAreaContext`.
         *
         * Requesting the height for width (or width for height) of an area is
         * a similar task except in this case the `GtkCellAreaContext` does not
         * store the data (actually, it does not know how much space the layouting
         * widget plans to allocate it for every row. It’s up to the layouting
         * widget to render each row of data with the appropriate height and
         * width which was requested by the `GtkCellArea`).
         *
         * In order to request the height for width of all the rows at the
         * root level of a `GtkTreeModel` one would do the following:
         *
         * ```c
         * GtkTreeIter iter;
         * int minimum_height;
         * int natural_height;
         * int full_minimum_height = 0;
         * int full_natural_height = 0;
         *
         * valid = gtk_tree_model_get_iter_first (model, &iter);
         * while (valid)
         *   {
         *     gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
         *     gtk_cell_area_get_preferred_height_for_width (area, context, widget,
         *                                                   width, &minimum_height, &natural_height);
         *
         *     if (width_is_for_allocation)
         *        cache_row_height (&iter, minimum_height, natural_height);
         *
         *     full_minimum_height += minimum_height;
         *     full_natural_height += natural_height;
         *
         *     valid = gtk_tree_model_iter_next (model, &iter);
         *   }
         * ```
         *
         * Note that in the above example we would need to cache the heights
         * returned for each row so that we would know what sizes to render the
         * areas for each row. However we would only want to really cache the
         * heights if the request is intended for the layouting widgets real
         * allocation.
         *
         * In some cases the layouting widget is requested the height for an
         * arbitrary for_width, this is a special case for layouting widgets
         * who need to request size for tens of thousands  of rows. For this
         * case it’s only important that the layouting widget calculate
         * one reasonably sized chunk of rows and return that height
         * synchronously. The reasoning here is that any layouting widget is
         * at least capable of synchronously calculating enough height to fill
         * the screen height (or scrolled window height) in response to a single
         * call to [vfunc`Gtk`.Widget.measure]. Returning
         * a perfect height for width that is larger than the screen area is
         * inconsequential since after the layouting receives an allocation
         * from a scrolled window it simply continues to drive the scrollbar
         * values while more and more height is required for the row heights
         * that are calculated in the background.
         *
         * ## Rendering Areas
         *
         * Once area sizes have been acquired at least for the rows in the
         * visible area of the layouting widget they can be rendered at
         * [vfunc`Gtk`.Widget.snapshot] time.
         *
         * A crude example of how to render all the rows at the root level
         * runs as follows:
         *
         * ```c
         * GtkAllocation allocation;
         * GdkRectangle cell_area = { 0, };
         * GtkTreeIter iter;
         * int minimum_width;
         * int natural_width;
         *
         * gtk_widget_get_allocation (widget, &allocation);
         * cell_area.width = allocation.width;
         *
         * valid = gtk_tree_model_get_iter_first (model, &iter);
         * while (valid)
         *   {
         *     cell_area.height = get_cached_height_for_row (&iter);
         *
         *     gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
         *     gtk_cell_area_render (area, context, widget, cr,
         *                           &cell_area, &cell_area, state_flags, FALSE);
         *
         *     cell_area.y += cell_area.height;
         *
         *     valid = gtk_tree_model_iter_next (model, &iter);
         *   }
         * ```
         *
         * Note that the cached height in this example really depends on how
         * the layouting widget works. The layouting widget might decide to
         * give every row its minimum or natural height or, if the model content
         * is expected to fit inside the layouting widget without scrolling, it
         * would make sense to calculate the allocation for each row at
         * the time the widget is allocated using [func`Gtk`.distribute_natural_allocation].
         *
         * ## Handling Events and Driving Keyboard Focus
         *
         * Passing events to the area is as simple as handling events on any
         * normal widget and then passing them to the [method`Gtk`.CellArea.event]
         * API as they come in. Usually `GtkCellArea` is only interested in
         * button events, however some customized derived areas can be implemented
         * who are interested in handling other events. Handling an event can
         * trigger the [signal`Gtk`.CellArea::focus-changed] signal to fire; as well
         * as [signal`Gtk`.CellArea::add-editable] in the case that an editable cell
         * was clicked and needs to start editing. You can call
         * [method`Gtk`.CellArea.stop_editing] at any time to cancel any cell editing
         * that is currently in progress.
         *
         * The `GtkCellArea` drives keyboard focus from cell to cell in a way
         * similar to `GtkWidget`. For layouting widgets that support giving
         * focus to cells it’s important to remember to pass `GTK_CELL_RENDERER_FOCUSED`
         * to the area functions for the row that has focus and to tell the
         * area to paint the focus at render time.
         *
         * Layouting widgets that accept focus on cells should implement the
         * [vfunc`Gtk`.Widget.focus] virtual method. The layouting widget is always
         * responsible for knowing where `GtkTreeModel` rows are rendered inside
         * the widget, so at [vfunc`Gtk`.Widget.focus] time the layouting widget
         * should use the `GtkCellArea` methods to navigate focus inside the area
         * and then observe the [enum`Gtk`.DirectionType] to pass the focus to adjacent
         * rows and areas.
         *
         * A basic example of how the [vfunc`Gtk`.Widget.focus] virtual method
         * should be implemented:
         *
         * ```
         * static gboolean
         * foo_focus (GtkWidget       *widget,
         *            GtkDirectionType direction)
         * {
         *   Foo *self = FOO (widget);
         *   FooPrivate *priv = foo_get_instance_private (self);
         *   int focus_row = priv->focus_row;
         *   gboolean have_focus = FALSE;
         *
         *   if (!gtk_widget_has_focus (widget))
         *     gtk_widget_grab_focus (widget);
         *
         *   valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, priv->focus_row);
         *   while (valid)
         *     {
         *       gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
         *
         *       if (gtk_cell_area_focus (priv->area, direction))
         *         {
         *            priv->focus_row = focus_row;
         *            have_focus = TRUE;
         *            break;
         *         }
         *       else
         *         {
         *           if (direction == GTK_DIR_RIGHT ||
         *               direction == GTK_DIR_LEFT)
         *             break;
         *           else if (direction == GTK_DIR_UP ||
         *                    direction == GTK_DIR_TAB_BACKWARD)
         *            {
         *               if (focus_row == 0)
         *                 break;
         *               else
         *                {
         *                   focus_row--;
         *                   valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, focus_row);
         *                }
         *             }
         *           else
         *             {
         *               if (focus_row == last_row)
         *                 break;
         *               else
         *                 {
         *                   focus_row++;
         *                   valid = gtk_tree_model_iter_next (priv->model, &iter);
         *                 }
         *             }
         *         }
         *     }
         *     return have_focus;
         * }
         * ```
         *
         * Note that the layouting widget is responsible for matching the
         * `GtkDirectionType` values to the way it lays out its cells.
         *
         * ## Cell Properties
         *
         * The `GtkCellArea` introduces cell properties for `GtkCellRenderer`s.
         * This provides some general interfaces for defining the relationship
         * cell areas have with their cells. For instance in a [class`Gtk`.CellAreaBox]
         * a cell might “expand” and receive extra space when the area is allocated
         * more than its full natural request, or a cell might be configured to “align”
         * with adjacent rows which were requested and rendered with the same
         * `GtkCellAreaContext`.
         *
         * Use [method`Gtk`.CellAreaClass.install_cell_property] to install cell
         * properties for a cell area class and [method`Gtk`.CellAreaClass.find_cell_property]
         * or [method`Gtk`.CellAreaClass.list_cell_properties] to get information about
         * existing cell properties.
         *
         * To set the value of a cell property, use [method`Gtk`.CellArea.cell_set_property],
         * [method`Gtk`.CellArea.cell_set] or [method`Gtk`.CellArea.cell_set_valist]. To obtain
         * the value of a cell property, use [method`Gtk`.CellArea.cell_get_property]
         * [method`Gtk`.CellArea.cell_get] or [method`Gtk`.CellArea.cell_get_valist].
         */
        abstract class CellArea extends GObject.InitiallyUnowned implements Buildable, CellLayout {
            static $gtype: GObject.GType<CellArea>;

            // Properties

            /**
             * The widget currently editing the edited cell
             *
             * This property is read-only and only changes as
             * a result of a call gtk_cell_area_activate_cell().
             */
            get edit_widget(): CellEditable;
            /**
             * The widget currently editing the edited cell
             *
             * This property is read-only and only changes as
             * a result of a call gtk_cell_area_activate_cell().
             */
            get editWidget(): CellEditable;
            /**
             * The cell in the area that is currently edited
             *
             * This property is read-only and only changes as
             * a result of a call gtk_cell_area_activate_cell().
             */
            get edited_cell(): CellRenderer;
            /**
             * The cell in the area that is currently edited
             *
             * This property is read-only and only changes as
             * a result of a call gtk_cell_area_activate_cell().
             */
            get editedCell(): CellRenderer;
            /**
             * The cell in the area that currently has focus
             */
            get focus_cell(): CellRenderer;
            set focus_cell(val: CellRenderer);
            /**
             * The cell in the area that currently has focus
             */
            get focusCell(): CellRenderer;
            set focusCell(val: CellRenderer);

            // Constructors

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

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

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(
                signal: 'add-editable',
                callback: (
                    _source: this,
                    renderer: CellRenderer,
                    editable: CellEditable,
                    cell_area: Gdk.Rectangle,
                    path: string,
                ) => void,
            ): number;
            connect_after(
                signal: 'add-editable',
                callback: (
                    _source: this,
                    renderer: CellRenderer,
                    editable: CellEditable,
                    cell_area: Gdk.Rectangle,
                    path: string,
                ) => void,
            ): number;
            emit(
                signal: 'add-editable',
                renderer: CellRenderer,
                editable: CellEditable,
                cell_area: Gdk.Rectangle,
                path: string,
            ): void;
            connect(
                signal: 'apply-attributes',
                callback: (
                    _source: this,
                    model: TreeModel,
                    iter: TreeIter,
                    is_expander: boolean,
                    is_expanded: boolean,
                ) => void,
            ): number;
            connect_after(
                signal: 'apply-attributes',
                callback: (
                    _source: this,
                    model: TreeModel,
                    iter: TreeIter,
                    is_expander: boolean,
                    is_expanded: boolean,
                ) => void,
            ): number;
            emit(
                signal: 'apply-attributes',
                model: TreeModel,
                iter: TreeIter,
                is_expander: boolean,
                is_expanded: boolean,
            ): void;
            connect(
                signal: 'focus-changed',
                callback: (_source: this, renderer: CellRenderer, path: string) => void,
            ): number;
            connect_after(
                signal: 'focus-changed',
                callback: (_source: this, renderer: CellRenderer, path: string) => void,
            ): number;
            emit(signal: 'focus-changed', renderer: CellRenderer, path: string): void;
            connect(
                signal: 'remove-editable',
                callback: (_source: this, renderer: CellRenderer, editable: CellEditable) => void,
            ): number;
            connect_after(
                signal: 'remove-editable',
                callback: (_source: this, renderer: CellRenderer, editable: CellEditable) => void,
            ): number;
            emit(signal: 'remove-editable', renderer: CellRenderer, editable: CellEditable): void;

            // Static methods

            static find_cell_property(property_name: string): GObject.ParamSpec;
            static install_cell_property(property_id: number, pspec: GObject.ParamSpec): void;
            static list_cell_properties(): GObject.ParamSpec[];

            // Virtual methods

            /**
             * Activates `area,` usually by activating the currently focused
             * cell, however some subclasses which embed widgets in the area
             * can also activate a widget if it currently has the focus.
             * @param context the `GtkCellArea`Context in context with the current row data
             * @param widget the `GtkWidget` that @area is rendering on
             * @param cell_area the size and location of @area relative to @widget’s allocation
             * @param flags the `GtkCellRenderer`State flags for @area for this row of data.
             * @param edit_only if %TRUE then only cell renderers that are %GTK_CELL_RENDERER_MODE_EDITABLE             will be activated.
             */
            vfunc_activate(
                context: CellAreaContext,
                widget: Widget,
                cell_area: Gdk.Rectangle,
                flags: CellRendererState,
                edit_only: boolean,
            ): boolean;
            /**
             * Adds `renderer` to `area` with the default child cell properties.
             * @param renderer the `GtkCellRenderer` to add to @area
             */
            vfunc_add(renderer: CellRenderer): void;
            /**
             * Applies any connected attributes to the renderers in
             * `area` by pulling the values from `tree_model`.
             * @param tree_model the `GtkTreeModel` to pull values from
             * @param iter the `GtkTreeIter` in @tree_model to apply values for
             * @param is_expander whether @iter has children
             * @param is_expanded whether @iter is expanded in the view and               children are visible
             */
            vfunc_apply_attributes(
                tree_model: TreeModel,
                iter: TreeIter,
                is_expander: boolean,
                is_expanded: boolean,
            ): void;
            /**
             * This is sometimes needed for cases where rows need to share
             * alignments in one orientation but may be separately grouped
             * in the opposing orientation.
             *
             * For instance, `GtkIconView` creates all icons (rows) to have
             * the same width and the cells theirin to have the same
             * horizontal alignments. However each row of icons may have
             * a separate collective height. `GtkIconView` uses this to
             * request the heights of each row based on a context which
             * was already used to request all the row widths that are
             * to be displayed.
             * @param context the `GtkCellArea`Context to copy
             */
            vfunc_copy_context(context: CellAreaContext): CellAreaContext;
            /**
             * Creates a `GtkCellArea`Context to be used with `area` for
             * all purposes. `GtkCellArea`Context stores geometry information
             * for rows for which it was operated on, it is important to use
             * the same context for the same row of data at all times (i.e.
             * one should render and handle events with the same `GtkCellArea`Context
             * which was used to request the size of those rows of data).
             */
            vfunc_create_context(): CellAreaContext;
            /**
             * Delegates event handling to a `GtkCellArea`.
             * @param context the `GtkCellArea`Context for this row of data.
             * @param widget the `GtkWidget` that @area is rendering to
             * @param event the `GdkEvent` to handle
             * @param cell_area the @widget relative coordinates for @area
             * @param flags the `GtkCellRenderer`State for @area in this row.
             */
            vfunc_event(
                context: CellAreaContext,
                widget: Widget,
                event: Gdk.Event,
                cell_area: Gdk.Rectangle,
                flags: CellRendererState,
            ): number;
            /**
             * This should be called by the `area’`s owning layout widget
             * when focus is to be passed to `area,` or moved within `area`
             * for a given `direction` and row data.
             *
             * Implementing `GtkCellArea` classes should implement this
             * method to receive and navigate focus in its own way particular
             * to how it lays out cells.
             * @param direction the `GtkDirectionType`
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Calls `callback` for every `GtkCellRenderer` in `area`.
             * @param callback the `GtkCellCallback` to call
             */
            vfunc_foreach(callback: CellCallback): void;
            /**
             * Calls `callback` for every `GtkCellRenderer` in `area` with the
             * allocated rectangle inside `cell_area`.
             * @param context the `GtkCellArea`Context for this row of data.
             * @param widget the `GtkWidget` that @area is rendering to
             * @param cell_area the @widget relative coordinates and size for @area
             * @param background_area the @widget relative coordinates of the background area
             * @param callback the `GtkCellAllocCallback` to call
             */
            vfunc_foreach_alloc(
                context: CellAreaContext,
                widget: Widget,
                cell_area: Gdk.Rectangle,
                background_area: Gdk.Rectangle,
                callback: CellAllocCallback,
            ): void;
            /**
             * This should be implemented to report the values of
             *   child cell properties for a given child `GtkCellRenderer`.
             * @param renderer
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_cell_property(
                renderer: CellRenderer,
                property_id: number,
                value: GObject.Value | any,
                pspec: GObject.ParamSpec,
            ): void;
            /**
             * Retrieves a cell area’s initial minimum and natural height.
             *
             * `area` will store some geometrical information in `context` along the way;
             * when requesting sizes over an arbitrary number of rows, it’s not important
             * to check the `minimum_height` and `natural_height` of this call but rather to
             * consult gtk_cell_area_context_get_preferred_height() after a series of
             * requests.
             * @param context the `GtkCellArea`Context to perform this request with
             * @param widget the `GtkWidget` where @area will be rendering
             */
            vfunc_get_preferred_height(context: CellAreaContext, widget: Widget): [number, number];
            /**
             * Retrieves a cell area’s minimum and natural height if it would be given
             * the specified `width`.
             *
             * `area` stores some geometrical information in `context` along the way
             * while calling gtk_cell_area_get_preferred_width(). It’s important to
             * perform a series of gtk_cell_area_get_preferred_width() requests with
             * `context` first and then call gtk_cell_area_get_preferred_height_for_width()
             * on each cell area individually to get the height for width of each
             * fully requested row.
             *
             * If at some point, the width of a single row changes, it should be
             * requested with gtk_cell_area_get_preferred_width() again and then
             * the full width of the requested rows checked again with
             * gtk_cell_area_context_get_preferred_width().
             * @param context the `GtkCellArea`Context which has already been requested for widths.
             * @param widget the `GtkWidget` where @area will be rendering
             * @param width the width for which to check the height of this area
             */
            vfunc_get_preferred_height_for_width(
                context: CellAreaContext,
                widget: Widget,
                width: number,
            ): [number, number];
            /**
             * Retrieves a cell area’s initial minimum and natural width.
             *
             * `area` will store some geometrical information in `context` along the way;
             * when requesting sizes over an arbitrary number of rows, it’s not important
             * to check the `minimum_width` and `natural_width` of this call but rather to
             * consult gtk_cell_area_context_get_preferred_width() after a series of
             * requests.
             * @param context the `GtkCellArea`Context to perform this request with
             * @param widget the `GtkWidget` where @area will be rendering
             */
            vfunc_get_preferred_width(context: CellAreaContext, widget: Widget): [number, number];
            /**
             * Retrieves a cell area’s minimum and natural width if it would be given
             * the specified `height`.
             *
             * `area` stores some geometrical information in `context` along the way
             * while calling gtk_cell_area_get_preferred_height(). It’s important to
             * perform a series of gtk_cell_area_get_preferred_height() requests with
             * `context` first and then call gtk_cell_area_get_preferred_width_for_height()
             * on each cell area individually to get the height for width of each
             * fully requested row.
             *
             * If at some point, the height of a single row changes, it should be
             * requested with gtk_cell_area_get_preferred_height() again and then
             * the full height of the requested rows checked again with
             * gtk_cell_area_context_get_preferred_height().
             * @param context the `GtkCellArea`Context which has already been requested for widths.
             * @param widget the `GtkWidget` where @area will be rendering
             * @param height the height for which to check the width of this area
             */
            vfunc_get_preferred_width_for_height(
                context: CellAreaContext,
                widget: Widget,
                height: number,
            ): [number, number];
            /**
             * Gets whether the area prefers a height-for-width layout
             * or a width-for-height layout.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Returns whether the area can do anything when activated,
             * after applying new attributes to `area`.
             */
            vfunc_is_activatable(): boolean;
            /**
             * Removes `renderer` from `area`.
             * @param renderer the `GtkCellRenderer` to remove from @area
             */
            vfunc_remove(renderer: CellRenderer): void;
            /**
             * This should be implemented to handle changes in child
             *   cell properties for a given `GtkCellRenderer` that were previously
             *   installed on the `GtkCellAreaClass` with gtk_cell_area_class_install_cell_property().
             * @param renderer
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_cell_property(
                renderer: CellRenderer,
                property_id: number,
                value: GObject.Value | any,
                pspec: GObject.ParamSpec,
            ): void;
            /**
             * Snapshots `area’`s cells according to `area’`s layout onto at
             * the given coordinates.
             * @param context the `GtkCellArea`Context for this row of data.
             * @param widget the `GtkWidget` that @area is rendering to
             * @param snapshot the `GtkSnapshot` to draw to
             * @param background_area the @widget relative coordinates for @area’s background
             * @param cell_area the @widget relative coordinates for @area
             * @param flags the `GtkCellRenderer`State for @area in this row.
             * @param paint_focus whether @area should paint focus on focused cells for focused rows or not.
             */
            vfunc_snapshot(
                context: CellAreaContext,
                widget: Widget,
                snapshot: Snapshot,
                background_area: Gdk.Rectangle,
                cell_area: Gdk.Rectangle,
                flags: CellRendererState,
                paint_focus: boolean,
            ): void;

            // Methods

            /**
             * Activates `area,` usually by activating the currently focused
             * cell, however some subclasses which embed widgets in the area
             * can also activate a widget if it currently has the focus.
             * @param context the `GtkCellArea`Context in context with the current row data
             * @param widget the `GtkWidget` that @area is rendering on
             * @param cell_area the size and location of @area relative to @widget’s allocation
             * @param flags the `GtkCellRenderer`State flags for @area for this row of data.
             * @param edit_only if %TRUE then only cell renderers that are %GTK_CELL_RENDERER_MODE_EDITABLE             will be activated.
             * @returns Whether @area was successfully activated.
             */
            activate(
                context: CellAreaContext,
                widget: Widget,
                cell_area: Gdk.Rectangle,
                flags: CellRendererState | null,
                edit_only: boolean,
            ): boolean;
            /**
             * This is used by `GtkCellArea` subclasses when handling events
             * to activate cells, the base `GtkCellArea` class activates cells
             * for keyboard events for free in its own GtkCellArea->activate()
             * implementation.
             * @param widget the `GtkWidget` that @area is rendering onto
             * @param renderer the `GtkCellRenderer` in @area to activate
             * @param event the `GdkEvent` for which cell activation should occur
             * @param cell_area the `GdkRectangle` in @widget relative coordinates             of @renderer for the current row.
             * @param flags the `GtkCellRenderer`State for @renderer
             * @returns whether cell activation was successful
             */
            activate_cell(
                widget: Widget,
                renderer: CellRenderer,
                event: Gdk.Event,
                cell_area: Gdk.Rectangle,
                flags: CellRendererState | null,
            ): boolean;
            /**
             * Adds `renderer` to `area` with the default child cell properties.
             * @param renderer the `GtkCellRenderer` to add to @area
             */
            add(renderer: CellRenderer): void;
            /**
             * Adds `sibling` to `renderer’`s focusable area, focus will be drawn
             * around `renderer` and all of its siblings if `renderer` can
             * focus for a given row.
             *
             * Events handled by focus siblings can also activate the given
             * focusable `renderer`.
             * @param renderer the `GtkCellRenderer` expected to have focus
             * @param sibling the `GtkCellRenderer` to add to @renderer’s focus area
             */
            add_focus_sibling(renderer: CellRenderer, sibling: CellRenderer): void;
            /**
             * Applies any connected attributes to the renderers in
             * `area` by pulling the values from `tree_model`.
             * @param tree_model the `GtkTreeModel` to pull values from
             * @param iter the `GtkTreeIter` in @tree_model to apply values for
             * @param is_expander whether @iter has children
             * @param is_expanded whether @iter is expanded in the view and               children are visible
             */
            apply_attributes(tree_model: TreeModel, iter: TreeIter, is_expander: boolean, is_expanded: boolean): void;
            /**
             * Connects an `attribute` to apply values from `column` for the
             * `GtkTreeModel` in use.
             * @param renderer the `GtkCellRenderer` to connect an attribute for
             * @param attribute the attribute name
             * @param column the `GtkTreeModel` column to fetch attribute values from
             */
            attribute_connect(renderer: CellRenderer, attribute: string, column: number): void;
            /**
             * Disconnects `attribute` for the `renderer` in `area` so that
             * attribute will no longer be updated with values from the
             * model.
             * @param renderer the `GtkCellRenderer` to disconnect an attribute for
             * @param attribute the attribute name
             */
            attribute_disconnect(renderer: CellRenderer, attribute: string): void;
            /**
             * Returns the model column that an attribute has been mapped to,
             * or -1 if the attribute is not mapped.
             * @param renderer a `GtkCellRenderer`
             * @param attribute an attribute on the renderer
             * @returns the model column, or -1
             */
            attribute_get_column(renderer: CellRenderer, attribute: string): number;
            /**
             * Gets the value of a cell property for `renderer` in `area`.
             * @param renderer a `GtkCellRenderer` inside @area
             * @param property_name the name of the property to get
             * @param value a location to return the value
             */
            cell_get_property(renderer: CellRenderer, property_name: string, value: GObject.Value | any): void;
            /**
             * Sets a cell property for `renderer` in `area`.
             * @param renderer a `GtkCellRenderer` inside @area
             * @param property_name the name of the cell property to set
             * @param value the value to set the cell property to
             */
            cell_set_property(renderer: CellRenderer, property_name: string, value: GObject.Value | any): void;
            /**
             * This is sometimes needed for cases where rows need to share
             * alignments in one orientation but may be separately grouped
             * in the opposing orientation.
             *
             * For instance, `GtkIconView` creates all icons (rows) to have
             * the same width and the cells theirin to have the same
             * horizontal alignments. However each row of icons may have
             * a separate collective height. `GtkIconView` uses this to
             * request the heights of each row based on a context which
             * was already used to request all the row widths that are
             * to be displayed.
             * @param context the `GtkCellArea`Context to copy
             * @returns a newly created `GtkCellArea`Context copy of @context.
             */
            copy_context(context: CellAreaContext): CellAreaContext;
            /**
             * Creates a `GtkCellArea`Context to be used with `area` for
             * all purposes. `GtkCellArea`Context stores geometry information
             * for rows for which it was operated on, it is important to use
             * the same context for the same row of data at all times (i.e.
             * one should render and handle events with the same `GtkCellArea`Context
             * which was used to request the size of those rows of data).
             * @returns a newly created `GtkCellArea`Context which can be used with @area.
             */
            create_context(): CellAreaContext;
            /**
             * Delegates event handling to a `GtkCellArea`.
             * @param context the `GtkCellArea`Context for this row of data.
             * @param widget the `GtkWidget` that @area is rendering to
             * @param event the `GdkEvent` to handle
             * @param cell_area the @widget relative coordinates for @area
             * @param flags the `GtkCellRenderer`State for @area in this row.
             * @returns %TRUE if the event was handled by @area.
             */
            event(
                context: CellAreaContext,
                widget: Widget,
                event: Gdk.Event,
                cell_area: Gdk.Rectangle,
                flags: CellRendererState | null,
            ): number;
            /**
             * This should be called by the `area’`s owning layout widget
             * when focus is to be passed to `area,` or moved within `area`
             * for a given `direction` and row data.
             *
             * Implementing `GtkCellArea` classes should implement this
             * method to receive and navigate focus in its own way particular
             * to how it lays out cells.
             * @param direction the `GtkDirectionType`
             * @returns %TRUE if focus remains inside @area as a result of this call.
             */
            focus(direction: DirectionType | null): boolean;
            /**
             * Calls `callback` for every `GtkCellRenderer` in `area`.
             * @param callback the `GtkCellCallback` to call
             */
            foreach(callback: CellCallback): void;
            /**
             * Calls `callback` for every `GtkCellRenderer` in `area` with the
             * allocated rectangle inside `cell_area`.
             * @param context the `GtkCellArea`Context for this row of data.
             * @param widget the `GtkWidget` that @area is rendering to
             * @param cell_area the @widget relative coordinates and size for @area
             * @param background_area the @widget relative coordinates of the background area
             * @param callback the `GtkCellAllocCallback` to call
             */
            foreach_alloc(
                context: CellAreaContext,
                widget: Widget,
                cell_area: Gdk.Rectangle,
                background_area: Gdk.Rectangle,
                callback: CellAllocCallback,
            ): void;
            /**
             * Derives the allocation of `renderer` inside `area` if `area`
             * were to be rendered in `cell_area`.
             * @param context the `GtkCellArea`Context used to hold sizes for @area.
             * @param widget the `GtkWidget` that @area is rendering on
             * @param renderer the `GtkCellRenderer` to get the allocation for
             * @param cell_area the whole allocated area for @area in @widget             for this row
             */
            get_cell_allocation(
                context: CellAreaContext,
                widget: Widget,
                renderer: CellRenderer,
                cell_area: Gdk.Rectangle,
            ): Gdk.Rectangle;
            /**
             * Gets the `GtkCellRenderer` at `x` and `y` coordinates inside `area` and optionally
             * returns the full cell allocation for it inside `cell_area`.
             * @param context the `GtkCellArea`Context used to hold sizes for @area.
             * @param widget the `GtkWidget` that @area is rendering on
             * @param cell_area the whole allocated area for @area in @widget   for this row
             * @param x the x position
             * @param y the y position
             * @returns the `GtkCellRenderer` at @x and @y.
             */
            get_cell_at_position(
                context: CellAreaContext,
                widget: Widget,
                cell_area: Gdk.Rectangle,
                x: number,
                y: number,
            ): [CellRenderer, Gdk.Rectangle | null];
            /**
             * Gets the current `GtkTreePath` string for the currently
             * applied `GtkTreeIter`, this is implicitly updated when
             * gtk_cell_area_apply_attributes() is called and can be
             * used to interact with renderers from `GtkCellArea`
             * subclasses.
             * @returns The current `GtkTreePath` string for the current attributes applied to @area. This string belongs to the area and should not be freed.
             */
            get_current_path_string(): string;
            /**
             * Gets the `GtkCellEditable` widget currently used
             * to edit the currently edited cell.
             * @returns The currently active `GtkCellEditable` widget
             */
            get_edit_widget(): CellEditable | null;
            /**
             * Gets the `GtkCellRenderer` in `area` that is currently
             * being edited.
             * @returns The currently edited `GtkCellRenderer`
             */
            get_edited_cell(): CellRenderer | null;
            /**
             * Retrieves the currently focused cell for `area`
             * @returns the currently focused cell in @area.
             */
            get_focus_cell(): CellRenderer | null;
            /**
             * Gets the `GtkCellRenderer` which is expected to be focusable
             * for which `renderer` is, or may be a sibling.
             *
             * This is handy for `GtkCellArea` subclasses when handling events,
             * after determining the renderer at the event location it can
             * then chose to activate the focus cell for which the event
             * cell may have been a sibling.
             * @param renderer the `GtkCellRenderer`
             * @returns the `GtkCellRenderer`   for which @renderer is a sibling
             */
            get_focus_from_sibling(renderer: CellRenderer): CellRenderer | null;
            /**
             * Gets the focus sibling cell renderers for `renderer`.
             * @param renderer the `GtkCellRenderer` expected to have focus
             * @returns A `GList` of `GtkCellRenderer`s.       The returned list is internal and should not be freed.
             */
            get_focus_siblings(renderer: CellRenderer): CellRenderer[];
            /**
             * Retrieves a cell area’s initial minimum and natural height.
             *
             * `area` will store some geometrical information in `context` along the way;
             * when requesting sizes over an arbitrary number of rows, it’s not important
             * to check the `minimum_height` and `natural_height` of this call but rather to
             * consult gtk_cell_area_context_get_preferred_height() after a series of
             * requests.
             * @param context the `GtkCellArea`Context to perform this request with
             * @param widget the `GtkWidget` where @area will be rendering
             */
            get_preferred_height(context: CellAreaContext, widget: Widget): [number, number];
            /**
             * Retrieves a cell area’s minimum and natural height if it would be given
             * the specified `width`.
             *
             * `area` stores some geometrical information in `context` along the way
             * while calling gtk_cell_area_get_preferred_width(). It’s important to
             * perform a series of gtk_cell_area_get_preferred_width() requests with
             * `context` first and then call gtk_cell_area_get_preferred_height_for_width()
             * on each cell area individually to get the height for width of each
             * fully requested row.
             *
             * If at some point, the width of a single row changes, it should be
             * requested with gtk_cell_area_get_preferred_width() again and then
             * the full width of the requested rows checked again with
             * gtk_cell_area_context_get_preferred_width().
             * @param context the `GtkCellArea`Context which has already been requested for widths.
             * @param widget the `GtkWidget` where @area will be rendering
             * @param width the width for which to check the height of this area
             */
            get_preferred_height_for_width(context: CellAreaContext, widget: Widget, width: number): [number, number];
            /**
             * Retrieves a cell area’s initial minimum and natural width.
             *
             * `area` will store some geometrical information in `context` along the way;
             * when requesting sizes over an arbitrary number of rows, it’s not important
             * to check the `minimum_width` and `natural_width` of this call but rather to
             * consult gtk_cell_area_context_get_preferred_width() after a series of
             * requests.
             * @param context the `GtkCellArea`Context to perform this request with
             * @param widget the `GtkWidget` where @area will be rendering
             */
            get_preferred_width(context: CellAreaContext, widget: Widget): [number, number];
            /**
             * Retrieves a cell area’s minimum and natural width if it would be given
             * the specified `height`.
             *
             * `area` stores some geometrical information in `context` along the way
             * while calling gtk_cell_area_get_preferred_height(). It’s important to
             * perform a series of gtk_cell_area_get_preferred_height() requests with
             * `context` first and then call gtk_cell_area_get_preferred_width_for_height()
             * on each cell area individually to get the height for width of each
             * fully requested row.
             *
             * If at some point, the height of a single row changes, it should be
             * requested with gtk_cell_area_get_preferred_height() again and then
             * the full height of the requested rows checked again with
             * gtk_cell_area_context_get_preferred_height().
             * @param context the `GtkCellArea`Context which has already been requested for widths.
             * @param widget the `GtkWidget` where @area will be rendering
             * @param height the height for which to check the width of this area
             */
            get_preferred_width_for_height(context: CellAreaContext, widget: Widget, height: number): [number, number];
            /**
             * Gets whether the area prefers a height-for-width layout
             * or a width-for-height layout.
             * @returns The `GtkSizeRequestMode` preferred by @area.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Checks if `area` contains `renderer`.
             * @param renderer the `GtkCellRenderer` to check
             * @returns %TRUE if @renderer is in the @area.
             */
            has_renderer(renderer: CellRenderer): boolean;
            /**
             * This is a convenience function for `GtkCellArea` implementations
             * to get the inner area where a given `GtkCellRenderer` will be
             * rendered. It removes any padding previously added by gtk_cell_area_request_renderer().
             * @param widget the `GtkWidget` that @area is rendering onto
             * @param cell_area the @widget relative coordinates where one of @area’s cells             is to be placed
             */
            inner_cell_area(widget: Widget, cell_area: Gdk.Rectangle): Gdk.Rectangle;
            /**
             * Returns whether the area can do anything when activated,
             * after applying new attributes to `area`.
             * @returns whether @area can do anything when activated.
             */
            is_activatable(): boolean;
            /**
             * Returns whether `sibling` is one of `renderer’`s focus siblings
             * (see gtk_cell_area_add_focus_sibling()).
             * @param renderer the `GtkCellRenderer` expected to have focus
             * @param sibling the `GtkCellRenderer` to check against @renderer’s sibling list
             * @returns %TRUE if @sibling is a focus sibling of @renderer
             */
            is_focus_sibling(renderer: CellRenderer, sibling: CellRenderer): boolean;
            /**
             * Removes `renderer` from `area`.
             * @param renderer the `GtkCellRenderer` to remove from @area
             */
            remove(renderer: CellRenderer): void;
            /**
             * Removes `sibling` from `renderer’`s focus sibling list
             * (see gtk_cell_area_add_focus_sibling()).
             * @param renderer the `GtkCellRenderer` expected to have focus
             * @param sibling the `GtkCellRenderer` to remove from @renderer’s focus area
             */
            remove_focus_sibling(renderer: CellRenderer, sibling: CellRenderer): void;
            /**
             * This is a convenience function for `GtkCellArea` implementations
             * to request size for cell renderers. It’s important to use this
             * function to request size and then use gtk_cell_area_inner_cell_area()
             * at render and event time since this function will add padding
             * around the cell for focus painting.
             * @param renderer the `GtkCellRenderer` to request size for
             * @param orientation the `GtkOrientation` in which to request size
             * @param widget the `GtkWidget` that @area is rendering onto
             * @param for_size the allocation contextual size to request for, or -1 if the base request for the orientation is to be returned.
             */
            request_renderer(
                renderer: CellRenderer,
                orientation: Orientation | null,
                widget: Widget,
                for_size: number,
            ): [number, number];
            /**
             * Explicitly sets the currently focused cell to `renderer`.
             *
             * This is generally called by implementations of
             * `GtkCellAreaClass.focus()` or `GtkCellAreaClass.event()`,
             * however it can also be used to implement functions such
             * as gtk_tree_view_set_cursor_on_cell().
             * @param renderer the `GtkCellRenderer` to give focus to
             */
            set_focus_cell(renderer?: CellRenderer | null): void;
            /**
             * Snapshots `area’`s cells according to `area’`s layout onto at
             * the given coordinates.
             * @param context the `GtkCellArea`Context for this row of data.
             * @param widget the `GtkWidget` that @area is rendering to
             * @param snapshot the `GtkSnapshot` to draw to
             * @param background_area the @widget relative coordinates for @area’s background
             * @param cell_area the @widget relative coordinates for @area
             * @param flags the `GtkCellRenderer`State for @area in this row.
             * @param paint_focus whether @area should paint focus on focused cells for focused rows or not.
             */
            snapshot(
                context: CellAreaContext,
                widget: Widget,
                snapshot: Snapshot,
                background_area: Gdk.Rectangle,
                cell_area: Gdk.Rectangle,
                flags: CellRendererState | null,
                paint_focus: boolean,
            ): void;
            /**
             * Explicitly stops the editing of the currently edited cell.
             *
             * If `canceled` is %TRUE, the currently edited cell renderer
             * will emit the ::editing-canceled signal, otherwise the
             * the ::editing-done signal will be emitted on the current
             * edit widget.
             *
             * See gtk_cell_area_get_edited_cell() and gtk_cell_area_get_edit_widget().
             * @param canceled whether editing was canceled.
             */
            stop_editing(canceled: boolean): void;

            // Inherited methods
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Adds an attribute mapping to the list in `cell_layout`.
             *
             * The `column` is the column of the model to get a value from, and the
             * `attribute` is the property on `cell` to be set from that value. So for
             * example if column 2 of the model contains strings, you could have the
             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
             * In this context "attribute" and "property" are used interchangeably.
             * @param cell a `GtkCellRenderer`
             * @param attribute a property on the renderer
             * @param column the column position on the model to get the attribute from
             */
            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
            /**
             * Unsets all the mappings on all renderers on `cell_layout` and
             * removes all renderers from `cell_layout`.
             */
            clear(): void;
            /**
             * Clears all existing attributes previously set with
             * gtk_cell_layout_set_attributes().
             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
             */
            clear_attributes(cell: CellRenderer): void;
            /**
             * Returns the underlying `GtkCellArea` which might be `cell_layout`
             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
             * is used by `cell_layout`.
             * @returns the cell area used by @cell_layout
             */
            get_area(): CellArea | null;
            /**
             * Returns the cell renderers which have been added to `cell_layout`.
             * @returns a list of cell renderers. The list, but not the renderers has   been newly allocated and should be freed with g_list_free()   when no longer needed.
             */
            get_cells(): CellRenderer[];
            /**
             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
             * `cell` is allocated no more space than it needs. Any unused space is
             * divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            pack_end(cell: CellRenderer, expand: boolean): void;
            /**
             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
             * then the `cell` is allocated no more space than it needs. Any unused space
             * is divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            pack_start(cell: CellRenderer, expand: boolean): void;
            /**
             * Re-inserts `cell` at `position`.
             *
             * Note that `cell` has already to be packed into `cell_layout`
             * for this to function properly.
             * @param cell a `GtkCellRenderer` to reorder
             * @param position new position to insert @cell at
             */
            reorder(cell: CellRenderer, position: number): void;
            /**
             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
             *
             * This function is used instead of the standard attributes mapping
             * for setting the column value, and should set the value of `cell_layout’`s
             * cell renderer(s) as appropriate.
             *
             * `func` may be %NULL to remove a previously set function.
             * @param cell a `GtkCellRenderer`
             * @param func the `GtkCellLayout`DataFunc to use
             */
            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
            /**
             * Adds an attribute mapping to the list in `cell_layout`.
             *
             * The `column` is the column of the model to get a value from, and the
             * `attribute` is the property on `cell` to be set from that value. So for
             * example if column 2 of the model contains strings, you could have the
             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
             * In this context "attribute" and "property" are used interchangeably.
             * @param cell a `GtkCellRenderer`
             * @param attribute a property on the renderer
             * @param column the column position on the model to get the attribute from
             */
            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
            /**
             * Unsets all the mappings on all renderers on `cell_layout` and
             * removes all renderers from `cell_layout`.
             */
            vfunc_clear(): void;
            /**
             * Clears all existing attributes previously set with
             * gtk_cell_layout_set_attributes().
             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
             */
            vfunc_clear_attributes(cell: CellRenderer): void;
            /**
             * Returns the underlying `GtkCellArea` which might be `cell_layout`
             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
             * is used by `cell_layout`.
             */
            vfunc_get_area(): CellArea | null;
            /**
             * Returns the cell renderers which have been added to `cell_layout`.
             */
            vfunc_get_cells(): CellRenderer[];
            /**
             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
             * `cell` is allocated no more space than it needs. Any unused space is
             * divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
            /**
             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
             * then the `cell` is allocated no more space than it needs. Any unused space
             * is divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
            /**
             * Re-inserts `cell` at `position`.
             *
             * Note that `cell` has already to be packed into `cell_layout`
             * for this to function properly.
             * @param cell a `GtkCellRenderer` to reorder
             * @param position new position to insert @cell at
             */
            vfunc_reorder(cell: CellRenderer, position: number): void;
            /**
             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
             *
             * This function is used instead of the standard attributes mapping
             * for setting the column value, and should set the value of `cell_layout’`s
             * cell renderer(s) as appropriate.
             *
             * `func` may be %NULL to remove a previously set function.
             * @param cell a `GtkCellRenderer`
             * @param func the `GtkCellLayout`DataFunc to use
             */
            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace CellAreaBox {
            // Constructor properties interface

            interface ConstructorProps
                extends CellArea.ConstructorProps,
                    Buildable.ConstructorProps,
                    CellLayout.ConstructorProps,
                    Orientable.ConstructorProps {
                spacing: number;
            }
        }

        /**
         * A cell area that renders GtkCellRenderers into a row or a column
         *
         * The `GtkCellAreaBox` renders cell renderers into a row or a column
         * depending on its `GtkOrientation`.
         *
         * GtkCellAreaBox uses a notion of packing. Packing
         * refers to adding cell renderers with reference to a particular position
         * in a `GtkCellAreaBox`. There are two reference positions: the
         * start and the end of the box.
         * When the `GtkCellAreaBox` is oriented in the %GTK_ORIENTATION_VERTICAL
         * orientation, the start is defined as the top of the box and the end is
         * defined as the bottom. In the %GTK_ORIENTATION_HORIZONTAL orientation
         * start is defined as the left side and the end is defined as the right
         * side.
         *
         * Alignments of `GtkCellRenderer`s rendered in adjacent rows can be
         * configured by configuring the `GtkCellAreaBox` align child cell property
         * with gtk_cell_area_cell_set_property() or by specifying the "align"
         * argument to gtk_cell_area_box_pack_start() and gtk_cell_area_box_pack_end().
         */
        class CellAreaBox extends CellArea implements Buildable, CellLayout, Orientable {
            static $gtype: GObject.GType<CellAreaBox>;

            // Properties

            /**
             * The amount of space to reserve between cells.
             */
            get spacing(): number;
            set spacing(val: number);

            // Constructors

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

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

            static ['new'](): CellAreaBox;

            // Methods

            /**
             * Gets the spacing added between cell renderers.
             * @returns the space added between cell renderers in @box.
             */
            get_spacing(): number;
            /**
             * Adds `renderer` to `box,` packed with reference to the end of `box`.
             *
             * The `renderer` is packed after (away from end of) any other
             * `GtkCellRenderer` packed with reference to the end of `box`.
             * @param renderer the `GtkCellRenderer` to add
             * @param expand whether @renderer should receive extra space when the area receives more than its natural size
             * @param align whether @renderer should be aligned in adjacent rows
             * @param fixed whether @renderer should have the same size in all rows
             */
            pack_end(renderer: CellRenderer, expand: boolean, align: boolean, fixed: boolean): void;
            // Conflicted with Gtk.CellLayout.pack_end
            pack_end(...args: never[]): any;
            /**
             * Adds `renderer` to `box,` packed with reference to the start of `box`.
             *
             * The `renderer` is packed after any other `GtkCellRenderer` packed
             * with reference to the start of `box`.
             * @param renderer the `GtkCellRenderer` to add
             * @param expand whether @renderer should receive extra space when the area receives more than its natural size
             * @param align whether @renderer should be aligned in adjacent rows
             * @param fixed whether @renderer should have the same size in all rows
             */
            pack_start(renderer: CellRenderer, expand: boolean, align: boolean, fixed: boolean): void;
            // Conflicted with Gtk.CellLayout.pack_start
            pack_start(...args: never[]): any;
            /**
             * Sets the spacing to add between cell renderers in `box`.
             * @param spacing the space to add between `GtkCellRenderer`s
             */
            set_spacing(spacing: number): void;

            // Inherited properties
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Inherited methods
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Adds an attribute mapping to the list in `cell_layout`.
             *
             * The `column` is the column of the model to get a value from, and the
             * `attribute` is the property on `cell` to be set from that value. So for
             * example if column 2 of the model contains strings, you could have the
             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
             * In this context "attribute" and "property" are used interchangeably.
             * @param cell a `GtkCellRenderer`
             * @param attribute a property on the renderer
             * @param column the column position on the model to get the attribute from
             */
            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
            /**
             * Unsets all the mappings on all renderers on `cell_layout` and
             * removes all renderers from `cell_layout`.
             */
            clear(): void;
            /**
             * Clears all existing attributes previously set with
             * gtk_cell_layout_set_attributes().
             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
             */
            clear_attributes(cell: CellRenderer): void;
            /**
             * Returns the underlying `GtkCellArea` which might be `cell_layout`
             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
             * is used by `cell_layout`.
             * @returns the cell area used by @cell_layout
             */
            get_area(): CellArea | null;
            /**
             * Returns the cell renderers which have been added to `cell_layout`.
             * @returns a list of cell renderers. The list, but not the renderers has   been newly allocated and should be freed with g_list_free()   when no longer needed.
             */
            get_cells(): CellRenderer[];
            /**
             * Re-inserts `cell` at `position`.
             *
             * Note that `cell` has already to be packed into `cell_layout`
             * for this to function properly.
             * @param cell a `GtkCellRenderer` to reorder
             * @param position new position to insert @cell at
             */
            reorder(cell: CellRenderer, position: number): void;
            /**
             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
             *
             * This function is used instead of the standard attributes mapping
             * for setting the column value, and should set the value of `cell_layout’`s
             * cell renderer(s) as appropriate.
             *
             * `func` may be %NULL to remove a previously set function.
             * @param cell a `GtkCellRenderer`
             * @param func the `GtkCellLayout`DataFunc to use
             */
            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
            /**
             * Adds an attribute mapping to the list in `cell_layout`.
             *
             * The `column` is the column of the model to get a value from, and the
             * `attribute` is the property on `cell` to be set from that value. So for
             * example if column 2 of the model contains strings, you could have the
             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
             * In this context "attribute" and "property" are used interchangeably.
             * @param cell a `GtkCellRenderer`
             * @param attribute a property on the renderer
             * @param column the column position on the model to get the attribute from
             */
            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
            /**
             * Unsets all the mappings on all renderers on `cell_layout` and
             * removes all renderers from `cell_layout`.
             */
            vfunc_clear(): void;
            /**
             * Clears all existing attributes previously set with
             * gtk_cell_layout_set_attributes().
             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
             */
            vfunc_clear_attributes(cell: CellRenderer): void;
            /**
             * Returns the underlying `GtkCellArea` which might be `cell_layout`
             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
             * is used by `cell_layout`.
             */
            vfunc_get_area(): CellArea | null;
            /**
             * Returns the cell renderers which have been added to `cell_layout`.
             */
            vfunc_get_cells(): CellRenderer[];
            /**
             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
             * `cell` is allocated no more space than it needs. Any unused space is
             * divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
            /**
             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
             * then the `cell` is allocated no more space than it needs. Any unused space
             * is divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
            /**
             * Re-inserts `cell` at `position`.
             *
             * Note that `cell` has already to be packed into `cell_layout`
             * for this to function properly.
             * @param cell a `GtkCellRenderer` to reorder
             * @param position new position to insert @cell at
             */
            vfunc_reorder(cell: CellRenderer, position: number): void;
            /**
             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
             *
             * This function is used instead of the standard attributes mapping
             * for setting the column value, and should set the value of `cell_layout’`s
             * cell renderer(s) as appropriate.
             *
             * `func` may be %NULL to remove a previously set function.
             * @param cell a `GtkCellRenderer`
             * @param func the `GtkCellLayout`DataFunc to use
             */
            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace CellAreaContext {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                area: CellArea;
                minimum_height: number;
                minimumHeight: number;
                minimum_width: number;
                minimumWidth: number;
                natural_height: number;
                naturalHeight: number;
                natural_width: number;
                naturalWidth: number;
            }
        }

        /**
         * Stores geometrical information for a series of rows in a GtkCellArea
         *
         * The `GtkCellAreaContext` object is created by a given `GtkCellArea`
         * implementation via its `GtkCellAreaClass.create_context()` virtual
         * method and is used to store cell sizes and alignments for a series of
         * `GtkTreeModel` rows that are requested and rendered in the same context.
         *
         * `GtkCellLayout` widgets can create any number of contexts in which to
         * request and render groups of data rows. However, it’s important that the
         * same context which was used to request sizes for a given `GtkTreeModel`
         * row also be used for the same row when calling other `GtkCellArea` APIs
         * such as gtk_cell_area_render() and gtk_cell_area_event().
         */
        class CellAreaContext extends GObject.Object {
            static $gtype: GObject.GType<CellAreaContext>;

            // Properties

            /**
             * The `GtkCellArea` this context was created by
             */
            get area(): CellArea;
            /**
             * The minimum height for the `GtkCellArea` in this context
             * for all `GtkTreeModel` rows that this context was requested
             * for using gtk_cell_area_get_preferred_height().
             */
            get minimum_height(): number;
            /**
             * The minimum height for the `GtkCellArea` in this context
             * for all `GtkTreeModel` rows that this context was requested
             * for using gtk_cell_area_get_preferred_height().
             */
            get minimumHeight(): number;
            /**
             * The minimum width for the `GtkCellArea` in this context
             * for all `GtkTreeModel` rows that this context was requested
             * for using gtk_cell_area_get_preferred_width().
             */
            get minimum_width(): number;
            /**
             * The minimum width for the `GtkCellArea` in this context
             * for all `GtkTreeModel` rows that this context was requested
             * for using gtk_cell_area_get_preferred_width().
             */
            get minimumWidth(): number;
            /**
             * The natural height for the `GtkCellArea` in this context
             * for all `GtkTreeModel` rows that this context was requested
             * for using gtk_cell_area_get_preferred_height().
             */
            get natural_height(): number;
            /**
             * The natural height for the `GtkCellArea` in this context
             * for all `GtkTreeModel` rows that this context was requested
             * for using gtk_cell_area_get_preferred_height().
             */
            get naturalHeight(): number;
            /**
             * The natural width for the `GtkCellArea` in this context
             * for all `GtkTreeModel` rows that this context was requested
             * for using gtk_cell_area_get_preferred_width().
             */
            get natural_width(): number;
            /**
             * The natural width for the `GtkCellArea` in this context
             * for all `GtkTreeModel` rows that this context was requested
             * for using gtk_cell_area_get_preferred_width().
             */
            get naturalWidth(): number;

            // Constructors

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

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

            // Virtual methods

            /**
             * Allocates a width and/or a height for all rows which are to be
             * rendered with `context`.
             *
             * Usually allocation is performed only horizontally or sometimes
             * vertically since a group of rows are usually rendered side by
             * side vertically or horizontally and share either the same width
             * or the same height. Sometimes they are allocated in both horizontal
             * and vertical orientations producing a homogeneous effect of the
             * rows. This is generally the case for `GtkTreeView` when
             * `GtkTreeView:fixed-height-mode` is enabled.
             * @param width the allocated width for all `GtkTreeModel` rows rendered   with @context, or -1
             * @param height the allocated height for all `GtkTreeModel` rows rendered   with @context, or -1
             */
            vfunc_allocate(width: number, height: number): void;
            /**
             * Gets the accumulative preferred height for `width` for all rows
             * which have been requested for the same said `width` with this context.
             *
             * After gtk_cell_area_context_reset() is called and/or before ever
             * requesting the size of a `GtkCellArea`, the returned values are -1.
             * @param width a proposed width for allocation
             */
            vfunc_get_preferred_height_for_width(width: number): [number, number];
            /**
             * Gets the accumulative preferred width for `height` for all rows which
             * have been requested for the same said `height` with this context.
             *
             * After gtk_cell_area_context_reset() is called and/or before ever
             * requesting the size of a `GtkCellArea`, the returned values are -1.
             * @param height a proposed height for allocation
             */
            vfunc_get_preferred_width_for_height(height: number): [number, number];
            /**
             * Resets any previously cached request and allocation
             * data.
             *
             * When underlying `GtkTreeModel` data changes its
             * important to reset the context if the content
             * size is allowed to shrink. If the content size
             * is only allowed to grow (this is usually an option
             * for views rendering large data stores as a measure
             * of optimization), then only the row that changed
             * or was inserted needs to be (re)requested with
             * gtk_cell_area_get_preferred_width().
             *
             * When the new overall size of the context requires
             * that the allocated size changes (or whenever this
             * allocation changes at all), the variable row
             * sizes need to be re-requested for every row.
             *
             * For instance, if the rows are displayed all with
             * the same width from top to bottom then a change
             * in the allocated width necessitates a recalculation
             * of all the displayed row heights using
             * gtk_cell_area_get_preferred_height_for_width().
             */
            vfunc_reset(): void;

            // Methods

            /**
             * Allocates a width and/or a height for all rows which are to be
             * rendered with `context`.
             *
             * Usually allocation is performed only horizontally or sometimes
             * vertically since a group of rows are usually rendered side by
             * side vertically or horizontally and share either the same width
             * or the same height. Sometimes they are allocated in both horizontal
             * and vertical orientations producing a homogeneous effect of the
             * rows. This is generally the case for `GtkTreeView` when
             * `GtkTreeView:fixed-height-mode` is enabled.
             * @param width the allocated width for all `GtkTreeModel` rows rendered   with @context, or -1
             * @param height the allocated height for all `GtkTreeModel` rows rendered   with @context, or -1
             */
            allocate(width: number, height: number): void;
            /**
             * Fetches the current allocation size for `context`.
             *
             * If the context was not allocated in width or height, or if the
             * context was recently reset with gtk_cell_area_context_reset(),
             * the returned value will be -1.
             */
            get_allocation(): [number, number];
            /**
             * Fetches the `GtkCellArea` this `context` was created by.
             *
             * This is generally unneeded by layouting widgets; however,
             * it is important for the context implementation itself to
             * fetch information about the area it is being used for.
             *
             * For instance at `GtkCellAreaContextClass.allocate()` time
             * it’s important to know details about any cell spacing
             * that the `GtkCellArea` is configured with in order to
             * compute a proper allocation.
             * @returns the `GtkCellArea` this context was created by.
             */
            get_area(): CellArea;
            /**
             * Gets the accumulative preferred height for all rows which have been
             * requested with this context.
             *
             * After gtk_cell_area_context_reset() is called and/or before ever
             * requesting the size of a `GtkCellArea`, the returned values are 0.
             */
            get_preferred_height(): [number, number];
            /**
             * Gets the accumulative preferred height for `width` for all rows
             * which have been requested for the same said `width` with this context.
             *
             * After gtk_cell_area_context_reset() is called and/or before ever
             * requesting the size of a `GtkCellArea`, the returned values are -1.
             * @param width a proposed width for allocation
             */
            get_preferred_height_for_width(width: number): [number, number];
            /**
             * Gets the accumulative preferred width for all rows which have been
             * requested with this context.
             *
             * After gtk_cell_area_context_reset() is called and/or before ever
             * requesting the size of a `GtkCellArea`, the returned values are 0.
             */
            get_preferred_width(): [number, number];
            /**
             * Gets the accumulative preferred width for `height` for all rows which
             * have been requested for the same said `height` with this context.
             *
             * After gtk_cell_area_context_reset() is called and/or before ever
             * requesting the size of a `GtkCellArea`, the returned values are -1.
             * @param height a proposed height for allocation
             */
            get_preferred_width_for_height(height: number): [number, number];
            /**
             * Causes the minimum and/or natural height to grow if the new
             * proposed sizes exceed the current minimum and natural height.
             *
             * This is used by `GtkCellAreaContext` implementations during
             * the request process over a series of `GtkTreeModel` rows to
             * progressively push the requested height over a series of
             * gtk_cell_area_get_preferred_height() requests.
             * @param minimum_height the proposed new minimum height for @context
             * @param natural_height the proposed new natural height for @context
             */
            push_preferred_height(minimum_height: number, natural_height: number): void;
            /**
             * Causes the minimum and/or natural width to grow if the new
             * proposed sizes exceed the current minimum and natural width.
             *
             * This is used by `GtkCellAreaContext` implementations during
             * the request process over a series of `GtkTreeModel` rows to
             * progressively push the requested width over a series of
             * gtk_cell_area_get_preferred_width() requests.
             * @param minimum_width the proposed new minimum width for @context
             * @param natural_width the proposed new natural width for @context
             */
            push_preferred_width(minimum_width: number, natural_width: number): void;
            /**
             * Resets any previously cached request and allocation
             * data.
             *
             * When underlying `GtkTreeModel` data changes its
             * important to reset the context if the content
             * size is allowed to shrink. If the content size
             * is only allowed to grow (this is usually an option
             * for views rendering large data stores as a measure
             * of optimization), then only the row that changed
             * or was inserted needs to be (re)requested with
             * gtk_cell_area_get_preferred_width().
             *
             * When the new overall size of the context requires
             * that the allocated size changes (or whenever this
             * allocation changes at all), the variable row
             * sizes need to be re-requested for every row.
             *
             * For instance, if the rows are displayed all with
             * the same width from top to bottom then a change
             * in the allocated width necessitates a recalculation
             * of all the displayed row heights using
             * gtk_cell_area_get_preferred_height_for_width().
             */
            reset(): void;
        }

        namespace CellRenderer {
            // Signal callback interfaces

            interface EditingCanceled {
                (): void;
            }

            interface EditingStarted {
                (editable: CellEditable, path: string): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.InitiallyUnowned.ConstructorProps {
                cell_background: string;
                cellBackground: string;
                cell_background_rgba: Gdk.RGBA;
                cellBackgroundRgba: Gdk.RGBA;
                cell_background_set: boolean;
                cellBackgroundSet: boolean;
                editing: boolean;
                height: number;
                is_expanded: boolean;
                isExpanded: boolean;
                is_expander: boolean;
                isExpander: boolean;
                mode: CellRendererMode;
                sensitive: boolean;
                visible: boolean;
                width: number;
                xalign: number;
                xpad: number;
                yalign: number;
                ypad: number;
            }
        }

        /**
         * An object for rendering a single cell
         *
         * The `GtkCellRenderer` is a base class of a set of objects used for
         * rendering a cell to a `cairo_t`.  These objects are used primarily by
         * the `GtkTreeView` widget, though they aren’t tied to them in any
         * specific way.  It is worth noting that `GtkCellRenderer` is not a
         * `GtkWidget` and cannot be treated as such.
         *
         * The primary use of a `GtkCellRenderer` is for drawing a certain graphical
         * elements on a `cairo_t`. Typically, one cell renderer is used to
         * draw many cells on the screen.  To this extent, it isn’t expected that a
         * CellRenderer keep any permanent state around.  Instead, any state is set
         * just prior to use using `GObject`s property system.  Then, the
         * cell is measured using gtk_cell_renderer_get_preferred_size(). Finally, the cell
         * is rendered in the correct location using gtk_cell_renderer_snapshot().
         *
         * There are a number of rules that must be followed when writing a new
         * `GtkCellRenderer`.  First and foremost, it’s important that a certain set
         * of properties will always yield a cell renderer of the same size,
         * barring a style change. The `GtkCellRenderer` also has a number of
         * generic properties that are expected to be honored by all children.
         *
         * Beyond merely rendering a cell, cell renderers can optionally
         * provide active user interface elements. A cell renderer can be
         * “activatable” like `GtkCellRenderer`Toggle,
         * which toggles when it gets activated by a mouse click, or it can be
         * “editable” like `GtkCellRenderer`Text, which
         * allows the user to edit the text using a widget implementing the
         * `GtkCellEditable` interface, e.g. `GtkEntry`.
         * To make a cell renderer activatable or editable, you have to
         * implement the `GtkCellRenderer`Class.activate or
         * `GtkCellRenderer`Class.start_editing virtual functions, respectively.
         *
         * Many properties of `GtkCellRenderer` and its subclasses have a
         * corresponding “set” property, e.g. “cell-background-set” corresponds
         * to “cell-background”. These “set” properties reflect whether a property
         * has been set or not. You should not set them independently.
         */
        abstract class CellRenderer extends GObject.InitiallyUnowned {
            static $gtype: GObject.GType<CellRenderer>;

            // Properties

            set cell_background(val: string);
            set cellBackground(val: string);
            /**
             * Cell background as a `GdkRGBA`
             */
            get cell_background_rgba(): Gdk.RGBA;
            set cell_background_rgba(val: Gdk.RGBA);
            /**
             * Cell background as a `GdkRGBA`
             */
            get cellBackgroundRgba(): Gdk.RGBA;
            set cellBackgroundRgba(val: Gdk.RGBA);
            get cell_background_set(): boolean;
            set cell_background_set(val: boolean);
            get cellBackgroundSet(): boolean;
            set cellBackgroundSet(val: boolean);
            get editing(): boolean;
            get height(): number;
            set height(val: number);
            get is_expanded(): boolean;
            set is_expanded(val: boolean);
            get isExpanded(): boolean;
            set isExpanded(val: boolean);
            get is_expander(): boolean;
            set is_expander(val: boolean);
            get isExpander(): boolean;
            set isExpander(val: boolean);
            get mode(): CellRendererMode;
            set mode(val: CellRendererMode);
            get sensitive(): boolean;
            set sensitive(val: boolean);
            get visible(): boolean;
            set visible(val: boolean);
            get width(): number;
            set width(val: number);
            get xalign(): number;
            set xalign(val: number);
            get xpad(): number;
            set xpad(val: number);
            get yalign(): number;
            set yalign(val: number);
            get ypad(): number;
            set ypad(val: number);

            // Constructors

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

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

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'editing-canceled', callback: (_source: this) => void): number;
            connect_after(signal: 'editing-canceled', callback: (_source: this) => void): number;
            emit(signal: 'editing-canceled'): void;
            connect(
                signal: 'editing-started',
                callback: (_source: this, editable: CellEditable, path: string) => void,
            ): number;
            connect_after(
                signal: 'editing-started',
                callback: (_source: this, editable: CellEditable, path: string) => void,
            ): number;
            emit(signal: 'editing-started', editable: CellEditable, path: string): void;

            // Virtual methods

            /**
             * Passes an activate event to the cell renderer for possible processing.
             * Some cell renderers may use events; for example, `GtkCellRendererToggle`
             * toggles when it gets a mouse click.
             * @param event a `GdkEvent`
             * @param widget widget that received the event
             * @param path widget-dependent string representation of the event location;    e.g. for `GtkTreeView`, a string representation of `GtkTreePath`
             * @param background_area background area as passed to gtk_cell_renderer_render()
             * @param cell_area cell area as passed to gtk_cell_renderer_render()
             * @param flags render flags
             */
            vfunc_activate(
                event: Gdk.Event,
                widget: Widget,
                path: string,
                background_area: Gdk.Rectangle,
                cell_area: Gdk.Rectangle,
                flags: CellRendererState,
            ): boolean;
            /**
             * Signal gets emitted when the user cancels the process of editing a cell.
             */
            vfunc_editing_canceled(): void;
            /**
             * Signal gets emitted when a cell starts to be edited.
             * @param editable
             * @param path
             */
            vfunc_editing_started(editable: CellEditable, path: string): void;
            /**
             * Gets the aligned area used by `cell` inside `cell_area`. Used for finding
             * the appropriate edit and focus rectangle.
             * @param widget the `GtkWidget` this cell will be rendering to
             * @param flags render flags
             * @param cell_area cell area which would be passed to gtk_cell_renderer_render()
             */
            vfunc_get_aligned_area(widget: Widget, flags: CellRendererState, cell_area: Gdk.Rectangle): Gdk.Rectangle;
            /**
             * Retrieves a renderer’s natural size when rendered to `widget`.
             * @param widget the `GtkWidget` this cell will be rendering to
             */
            vfunc_get_preferred_height(widget: Widget): [number, number];
            /**
             * Retrieves a cell renderers’s minimum and natural height if it were rendered to
             * `widget` with the specified `width`.
             * @param widget the `GtkWidget` this cell will be rendering to
             * @param width the size which is available for allocation
             */
            vfunc_get_preferred_height_for_width(widget: Widget, width: number): [number, number];
            /**
             * Retrieves a renderer’s natural size when rendered to `widget`.
             * @param widget the `GtkWidget` this cell will be rendering to
             */
            vfunc_get_preferred_width(widget: Widget): [number, number];
            /**
             * Retrieves a cell renderers’s minimum and natural width if it were rendered to
             * `widget` with the specified `height`.
             * @param widget the `GtkWidget` this cell will be rendering to
             * @param height the size which is available for allocation
             */
            vfunc_get_preferred_width_for_height(widget: Widget, height: number): [number, number];
            /**
             * Gets whether the cell renderer prefers a height-for-width layout
             * or a width-for-height layout.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Invokes the virtual render function of the `GtkCellRenderer`. The three
             * passed-in rectangles are areas in `cr`. Most renderers will draw within
             * `cell_area;` the xalign, yalign, xpad, and ypad fields of the `GtkCellRenderer`
             * should be honored with respect to `cell_area`. `background_area` includes the
             * blank space around the cell, and also the area containing the tree expander;
             * so the `background_area` rectangles for all cells tile to cover the entire
             * `window`.
             * @param snapshot a `GtkSnapshot` to draw to
             * @param widget the widget owning @window
             * @param background_area entire cell area (including tree expanders and maybe    padding on the sides)
             * @param cell_area area normally rendered by a cell renderer
             * @param flags flags that affect rendering
             */
            vfunc_snapshot(
                snapshot: Snapshot,
                widget: Widget,
                background_area: Gdk.Rectangle,
                cell_area: Gdk.Rectangle,
                flags: CellRendererState,
            ): void;
            /**
             * Starts editing the contents of this `cell,` through a new `GtkCellEditable`
             * widget created by the `GtkCellRenderer`Class.start_editing virtual function.
             * @param event a `GdkEvent`
             * @param widget widget that received the event
             * @param path widget-dependent string representation of the event location;    e.g. for `GtkTreeView`, a string representation of `GtkTreePath`
             * @param background_area background area as passed to gtk_cell_renderer_render()
             * @param cell_area cell area as passed to gtk_cell_renderer_render()
             * @param flags render flags
             */
            vfunc_start_editing(
                event: Gdk.Event | null,
                widget: Widget,
                path: string,
                background_area: Gdk.Rectangle,
                cell_area: Gdk.Rectangle,
                flags: CellRendererState,
            ): CellEditable | null;

            // Methods

            /**
             * Passes an activate event to the cell renderer for possible processing.
             * Some cell renderers may use events; for example, `GtkCellRendererToggle`
             * toggles when it gets a mouse click.
             * @param event a `GdkEvent`
             * @param widget widget that received the event
             * @param path widget-dependent string representation of the event location;    e.g. for `GtkTreeView`, a string representation of `GtkTreePath`
             * @param background_area background area as passed to gtk_cell_renderer_render()
             * @param cell_area cell area as passed to gtk_cell_renderer_render()
             * @param flags render flags
             * @returns %TRUE if the event was consumed/handled
             */
            activate(
                event: Gdk.Event,
                widget: Widget,
                path: string,
                background_area: Gdk.Rectangle,
                cell_area: Gdk.Rectangle,
                flags: CellRendererState | null,
            ): boolean;
            /**
             * Gets the aligned area used by `cell` inside `cell_area`. Used for finding
             * the appropriate edit and focus rectangle.
             * @param widget the `GtkWidget` this cell will be rendering to
             * @param flags render flags
             * @param cell_area cell area which would be passed to gtk_cell_renderer_render()
             */
            get_aligned_area(widget: Widget, flags: CellRendererState | null, cell_area: Gdk.Rectangle): Gdk.Rectangle;
            /**
             * Fills in `xalign` and `yalign` with the appropriate values of `cell`.
             */
            get_alignment(): [number, number];
            /**
             * Fills in `width` and `height` with the appropriate size of `cell`.
             */
            get_fixed_size(): [number, number];
            /**
             * Checks whether the given `GtkCellRenderer` is expanded.
             * @returns %TRUE if the cell renderer is expanded
             */
            get_is_expanded(): boolean;
            /**
             * Checks whether the given `GtkCellRenderer` is an expander.
             * @returns %TRUE if @cell is an expander, and %FALSE otherwise
             */
            get_is_expander(): boolean;
            /**
             * Fills in `xpad` and `ypad` with the appropriate values of `cell`.
             */
            get_padding(): [number, number];
            /**
             * Retrieves a renderer’s natural size when rendered to `widget`.
             * @param widget the `GtkWidget` this cell will be rendering to
             */
            get_preferred_height(widget: Widget): [number, number];
            /**
             * Retrieves a cell renderers’s minimum and natural height if it were rendered to
             * `widget` with the specified `width`.
             * @param widget the `GtkWidget` this cell will be rendering to
             * @param width the size which is available for allocation
             */
            get_preferred_height_for_width(widget: Widget, width: number): [number, number];
            /**
             * Retrieves the minimum and natural size of a cell taking
             * into account the widget’s preference for height-for-width management.
             * @param widget the `GtkWidget` this cell will be rendering to
             */
            get_preferred_size(widget: Widget): [Requisition | null, Requisition | null];
            /**
             * Retrieves a renderer’s natural size when rendered to `widget`.
             * @param widget the `GtkWidget` this cell will be rendering to
             */
            get_preferred_width(widget: Widget): [number, number];
            /**
             * Retrieves a cell renderers’s minimum and natural width if it were rendered to
             * `widget` with the specified `height`.
             * @param widget the `GtkWidget` this cell will be rendering to
             * @param height the size which is available for allocation
             */
            get_preferred_width_for_height(widget: Widget, height: number): [number, number];
            /**
             * Gets whether the cell renderer prefers a height-for-width layout
             * or a width-for-height layout.
             * @returns The `GtkSizeRequestMode` preferred by this renderer.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the cell renderer’s sensitivity.
             * @returns %TRUE if the cell renderer is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Translates the cell renderer state to `GtkStateFlags`,
             * based on the cell renderer and widget sensitivity, and
             * the given `GtkCellRenderer`State.
             * @param widget a `GtkWidget`
             * @param cell_state cell renderer state
             * @returns the widget state flags applying to @cell
             */
            get_state(widget: Widget | null, cell_state: CellRendererState | null): StateFlags;
            /**
             * Returns the cell renderer’s visibility.
             * @returns %TRUE if the cell renderer is visible
             */
            get_visible(): boolean;
            /**
             * Checks whether the cell renderer can do something when activated.
             * @returns %TRUE if the cell renderer can do anything when activated
             */
            is_activatable(): boolean;
            /**
             * Sets the renderer’s alignment within its available space.
             * @param xalign the x alignment of the cell renderer
             * @param yalign the y alignment of the cell renderer
             */
            set_alignment(xalign: number, yalign: number): void;
            /**
             * Sets the renderer size to be explicit, independent of the properties set.
             * @param width the width of the cell renderer, or -1
             * @param height the height of the cell renderer, or -1
             */
            set_fixed_size(width: number, height: number): void;
            /**
             * Sets whether the given `GtkCellRenderer` is expanded.
             * @param is_expanded whether @cell should be expanded
             */
            set_is_expanded(is_expanded: boolean): void;
            /**
             * Sets whether the given `GtkCellRenderer` is an expander.
             * @param is_expander whether @cell is an expander
             */
            set_is_expander(is_expander: boolean): void;
            /**
             * Sets the renderer’s padding.
             * @param xpad the x padding of the cell renderer
             * @param ypad the y padding of the cell renderer
             */
            set_padding(xpad: number, ypad: number): void;
            /**
             * Sets the cell renderer’s sensitivity.
             * @param sensitive the sensitivity of the cell
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the cell renderer’s visibility.
             * @param visible the visibility of the cell
             */
            set_visible(visible: boolean): void;
            /**
             * Invokes the virtual render function of the `GtkCellRenderer`. The three
             * passed-in rectangles are areas in `cr`. Most renderers will draw within
             * `cell_area;` the xalign, yalign, xpad, and ypad fields of the `GtkCellRenderer`
             * should be honored with respect to `cell_area`. `background_area` includes the
             * blank space around the cell, and also the area containing the tree expander;
             * so the `background_area` rectangles for all cells tile to cover the entire
             * `window`.
             * @param snapshot a `GtkSnapshot` to draw to
             * @param widget the widget owning @window
             * @param background_area entire cell area (including tree expanders and maybe    padding on the sides)
             * @param cell_area area normally rendered by a cell renderer
             * @param flags flags that affect rendering
             */
            snapshot(
                snapshot: Snapshot,
                widget: Widget,
                background_area: Gdk.Rectangle,
                cell_area: Gdk.Rectangle,
                flags: CellRendererState | null,
            ): void;
            /**
             * Starts editing the contents of this `cell,` through a new `GtkCellEditable`
             * widget created by the `GtkCellRenderer`Class.start_editing virtual function.
             * @param event a `GdkEvent`
             * @param widget widget that received the event
             * @param path widget-dependent string representation of the event location;    e.g. for `GtkTreeView`, a string representation of `GtkTreePath`
             * @param background_area background area as passed to gtk_cell_renderer_render()
             * @param cell_area cell area as passed to gtk_cell_renderer_render()
             * @param flags render flags
             * @returns A new `GtkCellEditable` for editing this   @cell, or %NULL if editing is not possible
             */
            start_editing(
                event: Gdk.Event | null,
                widget: Widget,
                path: string,
                background_area: Gdk.Rectangle,
                cell_area: Gdk.Rectangle,
                flags: CellRendererState | null,
            ): CellEditable | null;
            /**
             * Informs the cell renderer that the editing is stopped.
             * If `canceled` is %TRUE, the cell renderer will emit the
             * `GtkCellRenderer`::editing-canceled signal.
             *
             * This function should be called by cell renderer implementations
             * in response to the `GtkCellEditable::editing-done` signal of
             * `GtkCellEditable`.
             * @param canceled %TRUE if the editing has been canceled
             */
            stop_editing(canceled: boolean): void;
        }

        namespace CellRendererAccel {
            // Signal callback interfaces

            interface AccelCleared {
                (path_string: string): void;
            }

            interface AccelEdited {
                (path_string: string, accel_key: number, accel_mods: Gdk.ModifierType, hardware_keycode: number): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends CellRendererText.ConstructorProps {
                accel_key: number;
                accelKey: number;
                accel_mode: CellRendererAccelMode;
                accelMode: CellRendererAccelMode;
                accel_mods: Gdk.ModifierType;
                accelMods: Gdk.ModifierType;
                keycode: number;
            }
        }

        /**
         * Renders a keyboard accelerator in a cell
         *
         * `GtkCellRendererAccel` displays a keyboard accelerator (i.e. a key
         * combination like `Control + a`). If the cell renderer is editable,
         * the accelerator can be changed by simply typing the new combination.
         */
        class CellRendererAccel extends CellRendererText {
            static $gtype: GObject.GType<CellRendererAccel>;

            // Properties

            /**
             * The keyval of the accelerator.
             */
            get accel_key(): number;
            set accel_key(val: number);
            /**
             * The keyval of the accelerator.
             */
            get accelKey(): number;
            set accelKey(val: number);
            /**
             * Determines if the edited accelerators are GTK accelerators. If
             * they are, consumed modifiers are suppressed, only accelerators
             * accepted by GTK are allowed, and the accelerators are rendered
             * in the same way as they are in menus.
             */
            get accel_mode(): CellRendererAccelMode;
            set accel_mode(val: CellRendererAccelMode);
            /**
             * Determines if the edited accelerators are GTK accelerators. If
             * they are, consumed modifiers are suppressed, only accelerators
             * accepted by GTK are allowed, and the accelerators are rendered
             * in the same way as they are in menus.
             */
            get accelMode(): CellRendererAccelMode;
            set accelMode(val: CellRendererAccelMode);
            /**
             * The modifier mask of the accelerator.
             */
            get accel_mods(): Gdk.ModifierType;
            set accel_mods(val: Gdk.ModifierType);
            /**
             * The modifier mask of the accelerator.
             */
            get accelMods(): Gdk.ModifierType;
            set accelMods(val: Gdk.ModifierType);
            /**
             * The hardware keycode of the accelerator. Note that the hardware keycode is
             * only relevant if the key does not have a keyval. Normally, the keyboard
             * configuration should assign keyvals to all keys.
             */
            get keycode(): number;
            set keycode(val: number);

            // Constructors

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

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

            static ['new'](): CellRendererAccel;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'accel-cleared', callback: (_source: this, path_string: string) => void): number;
            connect_after(signal: 'accel-cleared', callback: (_source: this, path_string: string) => void): number;
            emit(signal: 'accel-cleared', path_string: string): void;
            connect(
                signal: 'accel-edited',
                callback: (
                    _source: this,
                    path_string: string,
                    accel_key: number,
                    accel_mods: Gdk.ModifierType,
                    hardware_keycode: number,
                ) => void,
            ): number;
            connect_after(
                signal: 'accel-edited',
                callback: (
                    _source: this,
                    path_string: string,
                    accel_key: number,
                    accel_mods: Gdk.ModifierType,
                    hardware_keycode: number,
                ) => void,
            ): number;
            emit(
                signal: 'accel-edited',
                path_string: string,
                accel_key: number,
                accel_mods: Gdk.ModifierType,
                hardware_keycode: number,
            ): void;
        }

        namespace CellRendererCombo {
            // Signal callback interfaces

            interface Changed {
                (path_string: string, new_iter: TreeIter): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends CellRendererText.ConstructorProps {
                has_entry: boolean;
                hasEntry: boolean;
                model: TreeModel;
                text_column: number;
                textColumn: number;
            }
        }

        /**
         * Renders a combobox in a cell
         *
         * `GtkCellRendererCombo` renders text in a cell like `GtkCellRendererText` from
         * which it is derived. But while `GtkCellRendererText` offers a simple entry to
         * edit the text, `GtkCellRendererCombo` offers a `GtkComboBox`
         * widget to edit the text. The values to display in the combo box are taken from
         * the tree model specified in the `GtkCellRendererCombo`:model property.
         *
         * The combo cell renderer takes care of adding a text cell renderer to the combo
         * box and sets it to display the column specified by its
         * `GtkCellRendererCombo`:text-column property. Further properties of the combo box
         * can be set in a handler for the `GtkCellRenderer::editing-started` signal.
         */
        class CellRendererCombo extends CellRendererText {
            static $gtype: GObject.GType<CellRendererCombo>;

            // Properties

            /**
             * If %TRUE, the cell renderer will include an entry and allow to enter
             * values other than the ones in the popup list.
             */
            get has_entry(): boolean;
            set has_entry(val: boolean);
            /**
             * If %TRUE, the cell renderer will include an entry and allow to enter
             * values other than the ones in the popup list.
             */
            get hasEntry(): boolean;
            set hasEntry(val: boolean);
            /**
             * Holds a tree model containing the possible values for the combo box.
             * Use the text_column property to specify the column holding the values.
             */
            get model(): TreeModel;
            set model(val: TreeModel);
            /**
             * Specifies the model column which holds the possible values for the
             * combo box.
             *
             * Note that this refers to the model specified in the model property,
             * not the model backing the tree view to which
             * this cell renderer is attached.
             *
             * `GtkCellRendererCombo` automatically adds a text cell renderer for
             * this column to its combo box.
             */
            get text_column(): number;
            set text_column(val: number);
            /**
             * Specifies the model column which holds the possible values for the
             * combo box.
             *
             * Note that this refers to the model specified in the model property,
             * not the model backing the tree view to which
             * this cell renderer is attached.
             *
             * `GtkCellRendererCombo` automatically adds a text cell renderer for
             * this column to its combo box.
             */
            get textColumn(): number;
            set textColumn(val: number);

            // Constructors

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

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

            static ['new'](): CellRendererCombo;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(
                signal: 'changed',
                callback: (_source: this, path_string: string, new_iter: TreeIter) => void,
            ): number;
            connect_after(
                signal: 'changed',
                callback: (_source: this, path_string: string, new_iter: TreeIter) => void,
            ): number;
            emit(signal: 'changed', path_string: string, new_iter: TreeIter): void;
        }

        namespace CellRendererPixbuf {
            // Constructor properties interface

            interface ConstructorProps extends CellRenderer.ConstructorProps {
                gicon: Gio.Icon;
                icon_name: string;
                iconName: string;
                icon_size: IconSize;
                iconSize: IconSize;
                pixbuf: GdkPixbuf.Pixbuf;
                pixbuf_expander_closed: GdkPixbuf.Pixbuf;
                pixbufExpanderClosed: GdkPixbuf.Pixbuf;
                pixbuf_expander_open: GdkPixbuf.Pixbuf;
                pixbufExpanderOpen: GdkPixbuf.Pixbuf;
                texture: Gdk.Texture;
            }
        }

        /**
         * Renders a pixbuf in a cell
         *
         * A `GtkCellRendererPixbuf` can be used to render an image in a cell. It allows
         * to render either a given `GdkPixbuf` (set via the
         * `GtkCellRendererPixbuf:pixbuf` property) or a named icon (set via the
         * `GtkCellRendererPixbuf:icon-name` property).
         *
         * To support the tree view, `GtkCellRendererPixbuf` also supports rendering two
         * alternative pixbufs, when the `GtkCellRenderer:is-expander` property is %TRUE.
         * If the `GtkCellRenderer:is-expanded property` is %TRUE and the
         * `GtkCellRendererPixbuf:pixbuf-expander-open` property is set to a pixbuf, it
         * renders that pixbuf, if the `GtkCellRenderer:is-expanded` property is %FALSE
         * and the `GtkCellRendererPixbuf:pixbuf-expander-closed` property is set to a
         * pixbuf, it renders that one.
         */
        class CellRendererPixbuf extends CellRenderer {
            static $gtype: GObject.GType<CellRendererPixbuf>;

            // Properties

            /**
             * The GIcon representing the icon to display.
             * If the icon theme is changed, the image will be updated
             * automatically.
             */
            get gicon(): Gio.Icon;
            set gicon(val: Gio.Icon);
            /**
             * The name of the themed icon to display.
             * This property only has an effect if not overridden by the "pixbuf" property.
             */
            get icon_name(): string;
            set icon_name(val: string);
            /**
             * The name of the themed icon to display.
             * This property only has an effect if not overridden by the "pixbuf" property.
             */
            get iconName(): string;
            set iconName(val: string);
            /**
             * The `GtkIconSize` value that specifies the size of the rendered icon.
             */
            get icon_size(): IconSize;
            set icon_size(val: IconSize);
            /**
             * The `GtkIconSize` value that specifies the size of the rendered icon.
             */
            get iconSize(): IconSize;
            set iconSize(val: IconSize);
            set pixbuf(val: GdkPixbuf.Pixbuf);
            get pixbuf_expander_closed(): GdkPixbuf.Pixbuf;
            set pixbuf_expander_closed(val: GdkPixbuf.Pixbuf);
            get pixbufExpanderClosed(): GdkPixbuf.Pixbuf;
            set pixbufExpanderClosed(val: GdkPixbuf.Pixbuf);
            get pixbuf_expander_open(): GdkPixbuf.Pixbuf;
            set pixbuf_expander_open(val: GdkPixbuf.Pixbuf);
            get pixbufExpanderOpen(): GdkPixbuf.Pixbuf;
            set pixbufExpanderOpen(val: GdkPixbuf.Pixbuf);
            get texture(): Gdk.Texture;
            set texture(val: Gdk.Texture);

            // Constructors

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

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

            static ['new'](): CellRendererPixbuf;
        }

        namespace CellRendererProgress {
            // Constructor properties interface

            interface ConstructorProps extends CellRenderer.ConstructorProps, Orientable.ConstructorProps {
                inverted: boolean;
                pulse: number;
                text: string;
                text_xalign: number;
                textXalign: number;
                text_yalign: number;
                textYalign: number;
                value: number;
            }
        }

        /**
         * Renders numbers as progress bars
         *
         * `GtkCellRendererProgress` renders a numeric value as a progress par in a cell.
         * Additionally, it can display a text on top of the progress bar.
         */
        class CellRendererProgress extends CellRenderer implements Orientable {
            static $gtype: GObject.GType<CellRendererProgress>;

            // Properties

            /**
             * Whether progess is inverted.
             */
            get inverted(): boolean;
            set inverted(val: boolean);
            /**
             * Setting this to a non-negative value causes the cell renderer to
             * enter "activity mode", where a block bounces back and forth to
             * indicate that some progress is made, without specifying exactly how
             * much.
             *
             * Each increment of the property causes the block to move by a little
             * bit.
             *
             * To indicate that the activity has not started yet, set the property
             * to zero. To indicate completion, set the property to %G_MAXINT.
             */
            get pulse(): number;
            set pulse(val: number);
            /**
             * The "text" property determines the label which will be drawn
             * over the progress bar. Setting this property to %NULL causes the default
             * label to be displayed. Setting this property to an empty string causes
             * no label to be displayed.
             */
            get text(): string;
            set text(val: string);
            /**
             * The "text-xalign" property controls the horizontal alignment of the
             * text in the progress bar.  Valid values range from 0 (left) to 1
             * (right).  Reserved for RTL layouts.
             */
            get text_xalign(): number;
            set text_xalign(val: number);
            /**
             * The "text-xalign" property controls the horizontal alignment of the
             * text in the progress bar.  Valid values range from 0 (left) to 1
             * (right).  Reserved for RTL layouts.
             */
            get textXalign(): number;
            set textXalign(val: number);
            /**
             * The "text-yalign" property controls the vertical alignment of the
             * text in the progress bar.  Valid values range from 0 (top) to 1
             * (bottom).
             */
            get text_yalign(): number;
            set text_yalign(val: number);
            /**
             * The "text-yalign" property controls the vertical alignment of the
             * text in the progress bar.  Valid values range from 0 (top) to 1
             * (bottom).
             */
            get textYalign(): number;
            set textYalign(val: number);
            /**
             * The "value" property determines the percentage to which the
             * progress bar will be "filled in".
             */
            get value(): number;
            set value(val: number);

            // Constructors

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

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

            static ['new'](): CellRendererProgress;

            // Inherited properties
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Inherited methods
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace CellRendererSpin {
            // Constructor properties interface

            interface ConstructorProps extends CellRendererText.ConstructorProps {
                adjustment: Adjustment;
                climb_rate: number;
                climbRate: number;
                digits: number;
            }
        }

        /**
         * Renders a spin button in a cell
         *
         * `GtkCellRendererSpin` renders text in a cell like `GtkCellRendererText` from
         * which it is derived. But while `GtkCellRendererText` offers a simple entry to
         * edit the text, `GtkCellRendererSpin` offers a `GtkSpinButton` widget. Of course,
         * that means that the text has to be parseable as a floating point number.
         *
         * The range of the spinbutton is taken from the adjustment property of the
         * cell renderer, which can be set explicitly or mapped to a column in the
         * tree model, like all properties of cell renders. `GtkCellRendererSpin`
         * also has properties for the `GtkCellRendererSpin:climb-rate` and the number
         * of `GtkCellRendererSpin:digits` to display. Other `GtkSpinButton` properties
         * can be set in a handler for the `GtkCellRenderer::editing-started` signal.
         */
        class CellRendererSpin extends CellRendererText {
            static $gtype: GObject.GType<CellRendererSpin>;

            // Properties

            /**
             * The adjustment that holds the value of the spinbutton.
             * This must be non-%NULL for the cell renderer to be editable.
             */
            get adjustment(): Adjustment;
            set adjustment(val: Adjustment);
            /**
             * The acceleration rate when you hold down a button.
             */
            get climb_rate(): number;
            set climb_rate(val: number);
            /**
             * The acceleration rate when you hold down a button.
             */
            get climbRate(): number;
            set climbRate(val: number);
            /**
             * The number of decimal places to display.
             */
            get digits(): number;
            set digits(val: number);

            // Constructors

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

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

            static ['new'](): CellRendererSpin;
        }

        namespace CellRendererSpinner {
            // Constructor properties interface

            interface ConstructorProps extends CellRenderer.ConstructorProps {
                active: boolean;
                pulse: number;
                size: IconSize;
            }
        }

        /**
         * Renders a spinning animation in a cell
         *
         * `GtkCellRendererSpinner` renders a spinning animation in a cell, very
         * similar to `GtkSpinner`. It can often be used as an alternative
         * to a `GtkCellRendererProgress` for displaying indefinite activity,
         * instead of actual progress.
         *
         * To start the animation in a cell, set the `GtkCellRendererSpinner:active`
         * property to %TRUE and increment the `GtkCellRendererSpinner:pulse` property
         * at regular intervals. The usual way to set the cell renderer properties
         * for each cell is to bind them to columns in your tree model using e.g.
         * gtk_tree_view_column_add_attribute().
         */
        class CellRendererSpinner extends CellRenderer {
            static $gtype: GObject.GType<CellRendererSpinner>;

            // Properties

            /**
             * Whether the spinner is active (ie. shown) in the cell
             */
            get active(): boolean;
            set active(val: boolean);
            /**
             * Pulse of the spinner. Increment this value to draw the next frame of the
             * spinner animation. Usually, you would update this value in a timeout.
             *
             * By default, the `GtkSpinner` widget draws one full cycle of the animation,
             * consisting of 12 frames, in 750 milliseconds.
             */
            get pulse(): number;
            set pulse(val: number);
            /**
             * The `GtkIconSize` value that specifies the size of the rendered spinner.
             */
            get size(): IconSize;
            set size(val: IconSize);

            // Constructors

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

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

            static ['new'](): CellRendererSpinner;
        }

        namespace CellRendererText {
            // Signal callback interfaces

            interface Edited {
                (path: string, new_text: string): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends CellRenderer.ConstructorProps {
                align_set: boolean;
                alignSet: boolean;
                alignment: Pango.Alignment;
                attributes: Pango.AttrList;
                background: string;
                background_rgba: Gdk.RGBA;
                backgroundRgba: Gdk.RGBA;
                background_set: boolean;
                backgroundSet: boolean;
                editable: boolean;
                editable_set: boolean;
                editableSet: boolean;
                ellipsize: Pango.EllipsizeMode;
                ellipsize_set: boolean;
                ellipsizeSet: boolean;
                family: string;
                family_set: boolean;
                familySet: boolean;
                font: string;
                font_desc: Pango.FontDescription;
                fontDesc: Pango.FontDescription;
                foreground: string;
                foreground_rgba: Gdk.RGBA;
                foregroundRgba: Gdk.RGBA;
                foreground_set: boolean;
                foregroundSet: boolean;
                language: string;
                language_set: boolean;
                languageSet: boolean;
                markup: string;
                max_width_chars: number;
                maxWidthChars: number;
                placeholder_text: string;
                placeholderText: string;
                rise: number;
                rise_set: boolean;
                riseSet: boolean;
                scale: number;
                scale_set: boolean;
                scaleSet: boolean;
                single_paragraph_mode: boolean;
                singleParagraphMode: boolean;
                size: number;
                size_points: number;
                sizePoints: number;
                size_set: boolean;
                sizeSet: boolean;
                stretch: Pango.Stretch;
                stretch_set: boolean;
                stretchSet: boolean;
                strikethrough: boolean;
                strikethrough_set: boolean;
                strikethroughSet: boolean;
                style: Pango.Style;
                style_set: boolean;
                styleSet: boolean;
                text: string;
                underline: Pango.Underline;
                underline_set: boolean;
                underlineSet: boolean;
                variant: Pango.Variant;
                variant_set: boolean;
                variantSet: boolean;
                weight: number;
                weight_set: boolean;
                weightSet: boolean;
                width_chars: number;
                widthChars: number;
                wrap_mode: Pango.WrapMode;
                wrapMode: Pango.WrapMode;
                wrap_width: number;
                wrapWidth: number;
            }
        }

        /**
         * Renders text in a cell
         *
         * A `GtkCellRendererText` renders a given text in its cell, using the font, color and
         * style information provided by its properties. The text will be ellipsized if it is
         * too long and the `GtkCellRendererText:ellipsize` property allows it.
         *
         * If the `GtkCellRenderer:mode` is %GTK_CELL_RENDERER_MODE_EDITABLE,
         * the `GtkCellRendererText` allows to edit its text using an entry.
         */
        class CellRendererText extends CellRenderer {
            static $gtype: GObject.GType<CellRendererText>;

            // Properties

            get align_set(): boolean;
            set align_set(val: boolean);
            get alignSet(): boolean;
            set alignSet(val: boolean);
            /**
             * Specifies how to align the lines of text with respect to each other.
             *
             * Note that this property describes how to align the lines of text in
             * case there are several of them. The "xalign" property of `GtkCellRenderer`,
             * on the other hand, sets the horizontal alignment of the whole text.
             */
            get alignment(): Pango.Alignment;
            set alignment(val: Pango.Alignment);
            get attributes(): Pango.AttrList;
            set attributes(val: Pango.AttrList);
            set background(val: string);
            /**
             * Background color as a `GdkRGBA`
             */
            get background_rgba(): Gdk.RGBA;
            set background_rgba(val: Gdk.RGBA);
            /**
             * Background color as a `GdkRGBA`
             */
            get backgroundRgba(): Gdk.RGBA;
            set backgroundRgba(val: Gdk.RGBA);
            get background_set(): boolean;
            set background_set(val: boolean);
            get backgroundSet(): boolean;
            set backgroundSet(val: boolean);
            get editable(): boolean;
            set editable(val: boolean);
            get editable_set(): boolean;
            set editable_set(val: boolean);
            get editableSet(): boolean;
            set editableSet(val: boolean);
            /**
             * Specifies the preferred place to ellipsize the string, if the cell renderer
             * does not have enough room to display the entire string. Setting it to
             * %PANGO_ELLIPSIZE_NONE turns off ellipsizing. See the wrap-width property
             * for another way of making the text fit into a given width.
             */
            get ellipsize(): Pango.EllipsizeMode;
            set ellipsize(val: Pango.EllipsizeMode);
            get ellipsize_set(): boolean;
            set ellipsize_set(val: boolean);
            get ellipsizeSet(): boolean;
            set ellipsizeSet(val: boolean);
            get family(): string;
            set family(val: string);
            get family_set(): boolean;
            set family_set(val: boolean);
            get familySet(): boolean;
            set familySet(val: boolean);
            get font(): string;
            set font(val: string);
            get font_desc(): Pango.FontDescription;
            set font_desc(val: Pango.FontDescription);
            get fontDesc(): Pango.FontDescription;
            set fontDesc(val: Pango.FontDescription);
            set foreground(val: string);
            /**
             * Foreground color as a `GdkRGBA`
             */
            get foreground_rgba(): Gdk.RGBA;
            set foreground_rgba(val: Gdk.RGBA);
            /**
             * Foreground color as a `GdkRGBA`
             */
            get foregroundRgba(): Gdk.RGBA;
            set foregroundRgba(val: Gdk.RGBA);
            get foreground_set(): boolean;
            set foreground_set(val: boolean);
            get foregroundSet(): boolean;
            set foregroundSet(val: boolean);
            get language(): string;
            set language(val: string);
            get language_set(): boolean;
            set language_set(val: boolean);
            get languageSet(): boolean;
            set languageSet(val: boolean);
            set markup(val: string);
            /**
             * The desired maximum width of the cell, in characters. If this property
             * is set to -1, the width will be calculated automatically.
             *
             * For cell renderers that ellipsize or wrap text; this property
             * controls the maximum reported width of the cell. The
             * cell should not receive any greater allocation unless it is
             * set to expand in its `GtkCellLayout` and all of the cell's siblings
             * have received their natural width.
             */
            get max_width_chars(): number;
            set max_width_chars(val: number);
            /**
             * The desired maximum width of the cell, in characters. If this property
             * is set to -1, the width will be calculated automatically.
             *
             * For cell renderers that ellipsize or wrap text; this property
             * controls the maximum reported width of the cell. The
             * cell should not receive any greater allocation unless it is
             * set to expand in its `GtkCellLayout` and all of the cell's siblings
             * have received their natural width.
             */
            get maxWidthChars(): number;
            set maxWidthChars(val: number);
            /**
             * The text that will be displayed in the `GtkCellRenderer` if
             * `GtkCellRendererText:editable` is %TRUE and the cell is empty.
             */
            get placeholder_text(): string;
            set placeholder_text(val: string);
            /**
             * The text that will be displayed in the `GtkCellRenderer` if
             * `GtkCellRendererText:editable` is %TRUE and the cell is empty.
             */
            get placeholderText(): string;
            set placeholderText(val: string);
            get rise(): number;
            set rise(val: number);
            get rise_set(): boolean;
            set rise_set(val: boolean);
            get riseSet(): boolean;
            set riseSet(val: boolean);
            get scale(): number;
            set scale(val: number);
            get scale_set(): boolean;
            set scale_set(val: boolean);
            get scaleSet(): boolean;
            set scaleSet(val: boolean);
            get single_paragraph_mode(): boolean;
            set single_paragraph_mode(val: boolean);
            get singleParagraphMode(): boolean;
            set singleParagraphMode(val: boolean);
            get size(): number;
            set size(val: number);
            get size_points(): number;
            set size_points(val: number);
            get sizePoints(): number;
            set sizePoints(val: number);
            get size_set(): boolean;
            set size_set(val: boolean);
            get sizeSet(): boolean;
            set sizeSet(val: boolean);
            get stretch(): Pango.Stretch;
            set stretch(val: Pango.Stretch);
            get stretch_set(): boolean;
            set stretch_set(val: boolean);
            get stretchSet(): boolean;
            set stretchSet(val: boolean);
            get strikethrough(): boolean;
            set strikethrough(val: boolean);
            get strikethrough_set(): boolean;
            set strikethrough_set(val: boolean);
            get strikethroughSet(): boolean;
            set strikethroughSet(val: boolean);
            get style(): Pango.Style;
            set style(val: Pango.Style);
            get style_set(): boolean;
            set style_set(val: boolean);
            get styleSet(): boolean;
            set styleSet(val: boolean);
            get text(): string;
            set text(val: string);
            get underline(): Pango.Underline;
            set underline(val: Pango.Underline);
            get underline_set(): boolean;
            set underline_set(val: boolean);
            get underlineSet(): boolean;
            set underlineSet(val: boolean);
            get variant(): Pango.Variant;
            set variant(val: Pango.Variant);
            get variant_set(): boolean;
            set variant_set(val: boolean);
            get variantSet(): boolean;
            set variantSet(val: boolean);
            get weight(): number;
            set weight(val: number);
            get weight_set(): boolean;
            set weight_set(val: boolean);
            get weightSet(): boolean;
            set weightSet(val: boolean);
            /**
             * The desired width of the cell, in characters. If this property is set to
             * -1, the width will be calculated automatically, otherwise the cell will
             * request either 3 characters or the property value, whichever is greater.
             */
            get width_chars(): number;
            set width_chars(val: number);
            /**
             * The desired width of the cell, in characters. If this property is set to
             * -1, the width will be calculated automatically, otherwise the cell will
             * request either 3 characters or the property value, whichever is greater.
             */
            get widthChars(): number;
            set widthChars(val: number);
            /**
             * Specifies how to break the string into multiple lines, if the cell
             * renderer does not have enough room to display the entire string.
             * This property has no effect unless the wrap-width property is set.
             */
            get wrap_mode(): Pango.WrapMode;
            set wrap_mode(val: Pango.WrapMode);
            /**
             * Specifies how to break the string into multiple lines, if the cell
             * renderer does not have enough room to display the entire string.
             * This property has no effect unless the wrap-width property is set.
             */
            get wrapMode(): Pango.WrapMode;
            set wrapMode(val: Pango.WrapMode);
            /**
             * Specifies the minimum width at which the text is wrapped. The wrap-mode property can
             * be used to influence at what character positions the line breaks can be placed.
             * Setting wrap-width to -1 turns wrapping off.
             */
            get wrap_width(): number;
            set wrap_width(val: number);
            /**
             * Specifies the minimum width at which the text is wrapped. The wrap-mode property can
             * be used to influence at what character positions the line breaks can be placed.
             * Setting wrap-width to -1 turns wrapping off.
             */
            get wrapWidth(): number;
            set wrapWidth(val: number);

            // Constructors

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

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

            static ['new'](): CellRendererText;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'edited', callback: (_source: this, path: string, new_text: string) => void): number;
            connect_after(signal: 'edited', callback: (_source: this, path: string, new_text: string) => void): number;
            emit(signal: 'edited', path: string, new_text: string): void;

            // Virtual methods

            vfunc_edited(path: string, new_text: string): void;

            // Methods

            /**
             * Sets the height of a renderer to explicitly be determined by the “font” and
             * “y_pad” property set on it.  Further changes in these properties do not
             * affect the height, so they must be accompanied by a subsequent call to this
             * function.  Using this function is inflexible, and should really only be used
             * if calculating the size of a cell is too slow (ie, a massive number of cells
             * displayed).  If `number_of_rows` is -1, then the fixed height is unset, and
             * the height is determined by the properties again.
             * @param number_of_rows Number of rows of text each cell renderer is allocated, or -1
             */
            set_fixed_height_from_font(number_of_rows: number): void;
        }

        namespace CellRendererToggle {
            // Signal callback interfaces

            interface Toggled {
                (path: string): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends CellRenderer.ConstructorProps {
                activatable: boolean;
                active: boolean;
                inconsistent: boolean;
                radio: boolean;
            }
        }

        /**
         * Renders a toggle button in a cell
         *
         * `GtkCellRendererToggle` renders a toggle button in a cell. The
         * button is drawn as a radio or a checkbutton, depending on the
         * `GtkCellRendererToggle:radio` property.
         * When activated, it emits the `GtkCellRendererToggle::toggled` signal.
         */
        class CellRendererToggle extends CellRenderer {
            static $gtype: GObject.GType<CellRendererToggle>;

            // Properties

            get activatable(): boolean;
            set activatable(val: boolean);
            get active(): boolean;
            set active(val: boolean);
            get inconsistent(): boolean;
            set inconsistent(val: boolean);
            get radio(): boolean;
            set radio(val: boolean);

            // Constructors

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

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

            static ['new'](): CellRendererToggle;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'toggled', callback: (_source: this, path: string) => void): number;
            connect_after(signal: 'toggled', callback: (_source: this, path: string) => void): number;
            emit(signal: 'toggled', path: string): void;

            // Methods

            /**
             * Returns whether the cell renderer is activatable. See
             * gtk_cell_renderer_toggle_set_activatable().
             * @returns %TRUE if the cell renderer is activatable.
             */
            get_activatable(): boolean;
            /**
             * Returns whether the cell renderer is active. See
             * gtk_cell_renderer_toggle_set_active().
             * @returns %TRUE if the cell renderer is active.
             */
            get_active(): boolean;
            /**
             * Returns whether we’re rendering radio toggles rather than checkboxes.
             * @returns %TRUE if we’re rendering radio toggles rather than checkboxes
             */
            get_radio(): boolean;
            /**
             * Makes the cell renderer activatable.
             * @param setting the value to set.
             */
            set_activatable(setting: boolean): void;
            /**
             * Activates or deactivates a cell renderer.
             * @param setting the value to set.
             */
            set_active(setting: boolean): void;
            /**
             * If `radio` is %TRUE, the cell renderer renders a radio toggle
             * (i.e. a toggle in a group of mutually-exclusive toggles).
             * If %FALSE, it renders a check toggle (a standalone boolean option).
             * This can be set globally for the cell renderer, or changed just
             * before rendering each cell in the model (for `GtkTreeView`, you set
             * up a per-row setting using `GtkTreeViewColumn` to associate model
             * columns with cell renderer properties).
             * @param radio %TRUE to make the toggle look like a radio button
             */
            set_radio(radio: boolean): void;
        }

        namespace CellView {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    CellLayout.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Orientable.ConstructorProps {
                cell_area: CellArea;
                cellArea: CellArea;
                cell_area_context: CellAreaContext;
                cellAreaContext: CellAreaContext;
                draw_sensitive: boolean;
                drawSensitive: boolean;
                fit_model: boolean;
                fitModel: boolean;
                model: TreeModel;
            }
        }

        /**
         * A widget displaying a single row of a GtkTreeModel
         *
         * A `GtkCellView` displays a single row of a `GtkTreeModel` using a `GtkCellArea`
         * and `GtkCellAreaContext`. A `GtkCellAreaContext` can be provided to the
         * `GtkCellView` at construction time in order to keep the cellview in context
         * of a group of cell views, this ensures that the renderers displayed will
         * be properly aligned with each other (like the aligned cells in the menus
         * of `GtkComboBox`).
         *
         * `GtkCellView` is `GtkOrientable` in order to decide in which orientation
         * the underlying `GtkCellAreaContext` should be allocated. Taking the `GtkComboBox`
         * menu as an example, cellviews should be oriented horizontally if the menus are
         * listed top-to-bottom and thus all share the same width but may have separate
         * individual heights (left-to-right menus should be allocated vertically since
         * they all share the same height but may have variable widths).
         *
         * ## CSS nodes
         *
         * GtkCellView has a single CSS node with name cellview.
         */
        class CellView extends Widget implements Accessible, Buildable, CellLayout, ConstraintTarget, Orientable {
            static $gtype: GObject.GType<CellView>;

            // Properties

            /**
             * The `GtkCellArea` rendering cells
             *
             * If no area is specified when creating the cell view with gtk_cell_view_new_with_context()
             * a horizontally oriented `GtkCellArea`Box will be used.
             *
             * since 3.0
             */
            get cell_area(): CellArea;
            /**
             * The `GtkCellArea` rendering cells
             *
             * If no area is specified when creating the cell view with gtk_cell_view_new_with_context()
             * a horizontally oriented `GtkCellArea`Box will be used.
             *
             * since 3.0
             */
            get cellArea(): CellArea;
            /**
             * The `GtkCellAreaContext` used to compute the geometry of the cell view.
             *
             * A group of cell views can be assigned the same context in order to
             * ensure the sizes and cell alignments match across all the views with
             * the same context.
             *
             * `GtkComboBox` menus uses this to assign the same context to all cell views
             * in the menu items for a single menu (each submenu creates its own
             * context since the size of each submenu does not depend on parent
             * or sibling menus).
             *
             * since 3.0
             */
            get cell_area_context(): CellAreaContext;
            /**
             * The `GtkCellAreaContext` used to compute the geometry of the cell view.
             *
             * A group of cell views can be assigned the same context in order to
             * ensure the sizes and cell alignments match across all the views with
             * the same context.
             *
             * `GtkComboBox` menus uses this to assign the same context to all cell views
             * in the menu items for a single menu (each submenu creates its own
             * context since the size of each submenu does not depend on parent
             * or sibling menus).
             *
             * since 3.0
             */
            get cellAreaContext(): CellAreaContext;
            /**
             * Whether all cells should be draw as sensitive for this view regardless
             * of the actual cell properties (used to make menus with submenus appear
             * sensitive when the items in submenus might be insensitive).
             *
             * since 3.0
             */
            get draw_sensitive(): boolean;
            set draw_sensitive(val: boolean);
            /**
             * Whether all cells should be draw as sensitive for this view regardless
             * of the actual cell properties (used to make menus with submenus appear
             * sensitive when the items in submenus might be insensitive).
             *
             * since 3.0
             */
            get drawSensitive(): boolean;
            set drawSensitive(val: boolean);
            /**
             * Whether the view should request enough space to always fit
             * the size of every row in the model (used by the combo box to
             * ensure the combo box size doesn't change when different items
             * are selected).
             *
             * since 3.0
             */
            get fit_model(): boolean;
            set fit_model(val: boolean);
            /**
             * Whether the view should request enough space to always fit
             * the size of every row in the model (used by the combo box to
             * ensure the combo box size doesn't change when different items
             * are selected).
             *
             * since 3.0
             */
            get fitModel(): boolean;
            set fitModel(val: boolean);
            /**
             * The model for cell view
             *
             * since 2.10
             */
            get model(): TreeModel;
            set model(val: TreeModel);

            // Constructors

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

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

            static ['new'](): CellView;

            static new_with_context(area: CellArea, context: CellAreaContext): CellView;

            static new_with_markup(markup: string): CellView;

            static new_with_text(text: string): CellView;

            static new_with_texture(texture: Gdk.Texture): CellView;

            // Methods

            /**
             * Returns a `GtkTreePath` referring to the currently
             * displayed row. If no row is currently displayed,
             * %NULL is returned.
             * @returns the currently displayed row
             */
            get_displayed_row(): TreePath | null;
            /**
             * Gets whether `cell_view` is configured to draw all of its
             * cells in a sensitive state.
             * @returns whether @cell_view draws all of its cells in a sensitive state
             */
            get_draw_sensitive(): boolean;
            /**
             * Gets whether `cell_view` is configured to request space
             * to fit the entire `GtkTreeModel`.
             * @returns whether @cell_view requests space to fit the entire `GtkTreeModel`.
             */
            get_fit_model(): boolean;
            /**
             * Returns the model for `cell_view`. If no model is used %NULL is
             * returned.
             * @returns a `GtkTreeModel` used
             */
            get_model(): TreeModel | null;
            /**
             * Sets the row of the model that is currently displayed
             * by the `GtkCellView`. If the path is unset, then the
             * contents of the cellview “stick” at their last value;
             * this is not normally a desired result, but may be
             * a needed intermediate state if say, the model for
             * the `GtkCellView` becomes temporarily empty.
             * @param path a `GtkTreePath` or %NULL to unset.
             */
            set_displayed_row(path?: TreePath | null): void;
            /**
             * Sets whether `cell_view` should draw all of its
             * cells in a sensitive state, this is used by `GtkComboBox` menus
             * to ensure that rows with insensitive cells that contain
             * children appear sensitive in the parent menu item.
             * @param draw_sensitive whether to draw all cells in a sensitive state.
             */
            set_draw_sensitive(draw_sensitive: boolean): void;
            /**
             * Sets whether `cell_view` should request space to fit the entire `GtkTreeModel`.
             *
             * This is used by `GtkComboBox` to ensure that the cell view displayed on
             * the combo box’s button always gets enough space and does not resize
             * when selection changes.
             * @param fit_model whether @cell_view should request space for the whole model.
             */
            set_fit_model(fit_model: boolean): void;
            /**
             * Sets the model for `cell_view`.  If `cell_view` already has a model
             * set, it will remove it before setting the new model.  If `model` is
             * %NULL, then it will unset the old model.
             * @param model a `GtkTreeModel`
             */
            set_model(model?: TreeModel | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Adds an attribute mapping to the list in `cell_layout`.
             *
             * The `column` is the column of the model to get a value from, and the
             * `attribute` is the property on `cell` to be set from that value. So for
             * example if column 2 of the model contains strings, you could have the
             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
             * In this context "attribute" and "property" are used interchangeably.
             * @param cell a `GtkCellRenderer`
             * @param attribute a property on the renderer
             * @param column the column position on the model to get the attribute from
             */
            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
            /**
             * Unsets all the mappings on all renderers on `cell_layout` and
             * removes all renderers from `cell_layout`.
             */
            clear(): void;
            /**
             * Clears all existing attributes previously set with
             * gtk_cell_layout_set_attributes().
             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
             */
            clear_attributes(cell: CellRenderer): void;
            /**
             * Returns the underlying `GtkCellArea` which might be `cell_layout`
             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
             * is used by `cell_layout`.
             * @returns the cell area used by @cell_layout
             */
            get_area(): CellArea | null;
            /**
             * Returns the cell renderers which have been added to `cell_layout`.
             * @returns a list of cell renderers. The list, but not the renderers has   been newly allocated and should be freed with g_list_free()   when no longer needed.
             */
            get_cells(): CellRenderer[];
            /**
             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
             * `cell` is allocated no more space than it needs. Any unused space is
             * divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            pack_end(cell: CellRenderer, expand: boolean): void;
            /**
             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
             * then the `cell` is allocated no more space than it needs. Any unused space
             * is divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            pack_start(cell: CellRenderer, expand: boolean): void;
            /**
             * Re-inserts `cell` at `position`.
             *
             * Note that `cell` has already to be packed into `cell_layout`
             * for this to function properly.
             * @param cell a `GtkCellRenderer` to reorder
             * @param position new position to insert @cell at
             */
            reorder(cell: CellRenderer, position: number): void;
            /**
             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
             *
             * This function is used instead of the standard attributes mapping
             * for setting the column value, and should set the value of `cell_layout’`s
             * cell renderer(s) as appropriate.
             *
             * `func` may be %NULL to remove a previously set function.
             * @param cell a `GtkCellRenderer`
             * @param func the `GtkCellLayout`DataFunc to use
             */
            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
            /**
             * Adds an attribute mapping to the list in `cell_layout`.
             *
             * The `column` is the column of the model to get a value from, and the
             * `attribute` is the property on `cell` to be set from that value. So for
             * example if column 2 of the model contains strings, you could have the
             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
             * In this context "attribute" and "property" are used interchangeably.
             * @param cell a `GtkCellRenderer`
             * @param attribute a property on the renderer
             * @param column the column position on the model to get the attribute from
             */
            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
            /**
             * Unsets all the mappings on all renderers on `cell_layout` and
             * removes all renderers from `cell_layout`.
             */
            vfunc_clear(): void;
            /**
             * Clears all existing attributes previously set with
             * gtk_cell_layout_set_attributes().
             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
             */
            vfunc_clear_attributes(cell: CellRenderer): void;
            /**
             * Returns the underlying `GtkCellArea` which might be `cell_layout`
             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
             * is used by `cell_layout`.
             */
            vfunc_get_area(): CellArea | null;
            /**
             * Returns the cell renderers which have been added to `cell_layout`.
             */
            vfunc_get_cells(): CellRenderer[];
            /**
             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
             * `cell` is allocated no more space than it needs. Any unused space is
             * divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
            /**
             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
             * then the `cell` is allocated no more space than it needs. Any unused space
             * is divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
            /**
             * Re-inserts `cell` at `position`.
             *
             * Note that `cell` has already to be packed into `cell_layout`
             * for this to function properly.
             * @param cell a `GtkCellRenderer` to reorder
             * @param position new position to insert @cell at
             */
            vfunc_reorder(cell: CellRenderer, position: number): void;
            /**
             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
             *
             * This function is used instead of the standard attributes mapping
             * for setting the column value, and should set the value of `cell_layout’`s
             * cell renderer(s) as appropriate.
             *
             * `func` may be %NULL to remove a previously set function.
             * @param cell a `GtkCellRenderer`
             * @param func the `GtkCellLayout`DataFunc to use
             */
            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace CenterBox {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Orientable.ConstructorProps {
                baseline_position: BaselinePosition;
                baselinePosition: BaselinePosition;
                center_widget: Widget;
                centerWidget: Widget;
                end_widget: Widget;
                endWidget: Widget;
                shrink_center_last: boolean;
                shrinkCenterLast: boolean;
                start_widget: Widget;
                startWidget: Widget;
            }
        }

        /**
         * `GtkCenterBox` arranges three children in a row, keeping the middle child
         * centered as well as possible.
         *
         * ![An example GtkCenterBox](centerbox.png)
         *
         * To add children to `GtkCenterBox`, use [method`Gtk`.CenterBox.set_start_widget],
         * [method`Gtk`.CenterBox.set_center_widget] and
         * [method`Gtk`.CenterBox.set_end_widget].
         *
         * The sizing and positioning of children can be influenced with the
         * align and expand properties of the children.
         *
         * # GtkCenterBox as GtkBuildable
         *
         * The `GtkCenterBox` implementation of the `GtkBuildable` interface
         * supports placing children in the 3 positions by specifying “start”, “center”
         * or “end” as the “type” attribute of a `<child>` element.
         *
         * # CSS nodes
         *
         * `GtkCenterBox` uses a single CSS node with the name “box”,
         *
         * The first child of the `GtkCenterBox` will be allocated depending on the
         * text direction, i.e. in left-to-right layouts it will be allocated on the
         * left and in right-to-left layouts on the right.
         *
         * In vertical orientation, the nodes of the children are arranged from top to
         * bottom.
         *
         * # Accessibility
         *
         * Until GTK 4.10, `GtkCenterBox` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
         *
         * Starting from GTK 4.12, `GtkCenterBox` uses the `GTK_ACCESSIBLE_ROLE_GENERIC` role.
         */
        class CenterBox extends Widget implements Accessible, Buildable, ConstraintTarget, Orientable {
            static $gtype: GObject.GType<CenterBox>;

            // Properties

            /**
             * The position of the baseline aligned widget if extra space is available.
             */
            get baseline_position(): BaselinePosition;
            set baseline_position(val: BaselinePosition);
            /**
             * The position of the baseline aligned widget if extra space is available.
             */
            get baselinePosition(): BaselinePosition;
            set baselinePosition(val: BaselinePosition);
            /**
             * The widget that is placed at the center position.
             */
            get center_widget(): Widget;
            set center_widget(val: Widget);
            /**
             * The widget that is placed at the center position.
             */
            get centerWidget(): Widget;
            set centerWidget(val: Widget);
            /**
             * The widget that is placed at the end position.
             *
             * In vertical orientation, the end position is at the bottom.
             * In horizontal orientation, the end position is at the trailing
             * edge wrt. to the text direction.
             */
            get end_widget(): Widget;
            set end_widget(val: Widget);
            /**
             * The widget that is placed at the end position.
             *
             * In vertical orientation, the end position is at the bottom.
             * In horizontal orientation, the end position is at the trailing
             * edge wrt. to the text direction.
             */
            get endWidget(): Widget;
            set endWidget(val: Widget);
            /**
             * Whether to shrink the center widget after other children.
             *
             * By default, when there's no space to give all three children their
             * natural widths, the start and end widgets start shrinking and the
             * center child keeps natural width until they reach minimum width.
             *
             * If set to `FALSE`, start and end widgets keep natural width and the
             * center widget starts shrinking instead.
             */
            get shrink_center_last(): boolean;
            set shrink_center_last(val: boolean);
            /**
             * Whether to shrink the center widget after other children.
             *
             * By default, when there's no space to give all three children their
             * natural widths, the start and end widgets start shrinking and the
             * center child keeps natural width until they reach minimum width.
             *
             * If set to `FALSE`, start and end widgets keep natural width and the
             * center widget starts shrinking instead.
             */
            get shrinkCenterLast(): boolean;
            set shrinkCenterLast(val: boolean);
            /**
             * The widget that is placed at the start position.
             *
             * In vertical orientation, the start position is at the top.
             * In horizontal orientation, the start position is at the leading
             * edge wrt. to the text direction.
             */
            get start_widget(): Widget;
            set start_widget(val: Widget);
            /**
             * The widget that is placed at the start position.
             *
             * In vertical orientation, the start position is at the top.
             * In horizontal orientation, the start position is at the leading
             * edge wrt. to the text direction.
             */
            get startWidget(): Widget;
            set startWidget(val: Widget);

            // Constructors

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

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

            static ['new'](): CenterBox;

            // Methods

            /**
             * Gets the value set by gtk_center_box_set_baseline_position().
             * @returns the baseline position
             */
            get_baseline_position(): BaselinePosition;
            /**
             * Gets the center widget, or %NULL if there is none.
             * @returns the center widget.
             */
            get_center_widget(): Widget | null;
            /**
             * Gets the end widget, or %NULL if there is none.
             * @returns the end widget.
             */
            get_end_widget(): Widget | null;
            /**
             * Gets whether `self` shrinks the center widget after other children.
             * @returns whether to shrink the center widget after others
             */
            get_shrink_center_last(): boolean;
            /**
             * Gets the start widget, or %NULL if there is none.
             * @returns the start widget.
             */
            get_start_widget(): Widget | null;
            /**
             * Sets the baseline position of a center box.
             *
             * This affects only horizontal boxes with at least one baseline
             * aligned child. If there is more vertical space available than
             * requested, and the baseline is not allocated by the parent then
             * `position` is used to allocate the baseline wrt. the extra space
             * available.
             * @param position a `GtkBaselinePosition`
             */
            set_baseline_position(position: BaselinePosition | null): void;
            /**
             * Sets the center widget.
             *
             * To remove the existing center widget, pass %NULL.
             * @param child the new center widget
             */
            set_center_widget(child?: Widget | null): void;
            /**
             * Sets the end widget.
             *
             * To remove the existing end widget, pass %NULL.
             * @param child the new end widget
             */
            set_end_widget(child?: Widget | null): void;
            /**
             * Sets whether to shrink the center widget after other children.
             *
             * By default, when there's no space to give all three children their
             * natural widths, the start and end widgets start shrinking and the
             * center child keeps natural width until they reach minimum width.
             *
             * If set to `FALSE`, start and end widgets keep natural width and the
             * center widget starts shrinking instead.
             * @param shrink_center_last whether to shrink the center widget after others
             */
            set_shrink_center_last(shrink_center_last: boolean): void;
            /**
             * Sets the start widget.
             *
             * To remove the existing start widget, pass %NULL.
             * @param child the new start widget
             */
            set_start_widget(child?: Widget | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace CenterLayout {
            // Constructor properties interface

            interface ConstructorProps extends LayoutManager.ConstructorProps {
                shrink_center_last: boolean;
                shrinkCenterLast: boolean;
            }
        }

        /**
         * `GtkCenterLayout` is a layout manager that manages up to three children.
         *
         * The start widget is allocated at the start of the layout (left in
         * left-to-right locales and right in right-to-left ones), and the end
         * widget at the end.
         *
         * The center widget is centered regarding the full width of the layout's.
         */
        class CenterLayout extends LayoutManager {
            static $gtype: GObject.GType<CenterLayout>;

            // Properties

            /**
             * Whether to shrink the center widget after other children.
             *
             * By default, when there's no space to give all three children their
             * natural widths, the start and end widgets start shrinking and the
             * center child keeps natural width until they reach minimum width.
             *
             * If set to `FALSE`, start and end widgets keep natural width and the
             * center widget starts shrinking instead.
             */
            get shrink_center_last(): boolean;
            set shrink_center_last(val: boolean);
            /**
             * Whether to shrink the center widget after other children.
             *
             * By default, when there's no space to give all three children their
             * natural widths, the start and end widgets start shrinking and the
             * center child keeps natural width until they reach minimum width.
             *
             * If set to `FALSE`, start and end widgets keep natural width and the
             * center widget starts shrinking instead.
             */
            get shrinkCenterLast(): boolean;
            set shrinkCenterLast(val: boolean);

            // Constructors

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

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

            static ['new'](): CenterLayout;

            // Methods

            /**
             * Returns the baseline position of the layout.
             * @returns The current baseline position of @self.
             */
            get_baseline_position(): BaselinePosition;
            /**
             * Returns the center widget of the layout.
             * @returns the current center widget of @self
             */
            get_center_widget(): Widget | null;
            /**
             * Returns the end widget of the layout.
             * @returns the current end widget of @self
             */
            get_end_widget(): Widget | null;
            /**
             * Gets the current orienration of the layout manager.
             * @returns The current orientation of @self
             */
            get_orientation(): Orientation;
            /**
             * Gets whether `self` shrinks the center widget after other children.
             * @returns whether to shrink the center widget after others
             */
            get_shrink_center_last(): boolean;
            /**
             * Returns the start widget of the layout.
             * @returns The current start widget of @self
             */
            get_start_widget(): Widget | null;
            /**
             * Sets the new baseline position of `self`
             * @param baseline_position the new baseline position
             */
            set_baseline_position(baseline_position: BaselinePosition | null): void;
            /**
             * Sets the new center widget of `self`.
             *
             * To remove the existing center widget, pass %NULL.
             * @param widget the new center widget
             */
            set_center_widget(widget?: Widget | null): void;
            /**
             * Sets the new end widget of `self`.
             *
             * To remove the existing center widget, pass %NULL.
             * @param widget the new end widget
             */
            set_end_widget(widget?: Widget | null): void;
            /**
             * Sets the orientation of `self`.
             * @param orientation the new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Sets whether to shrink the center widget after other children.
             *
             * By default, when there's no space to give all three children their
             * natural widths, the start and end widgets start shrinking and the
             * center child keeps natural width until they reach minimum width.
             *
             * If set to `FALSE`, start and end widgets keep natural width and the
             * center widget starts shrinking instead.
             * @param shrink_center_last whether to shrink the center widget after others
             */
            set_shrink_center_last(shrink_center_last: boolean): void;
            /**
             * Sets the new start widget of `self`.
             *
             * To remove the existing start widget, pass %NULL.
             * @param widget the new start widget
             */
            set_start_widget(widget?: Widget | null): void;
        }

        namespace CheckButton {
            // Signal callback interfaces

            interface Activate {
                (): void;
            }

            interface Toggled {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Actionable.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                active: boolean;
                child: Widget;
                group: CheckButton;
                inconsistent: boolean;
                label: string;
                use_underline: boolean;
                useUnderline: boolean;
            }
        }

        /**
         * A `GtkCheckButton` places a label next to an indicator.
         *
         * ![Example GtkCheckButtons](check-button.png)
         *
         * A `GtkCheckButton` is created by calling either [ctor`Gtk`.CheckButton.new]
         * or [ctor`Gtk`.CheckButton.new_with_label].
         *
         * The state of a `GtkCheckButton` can be set specifically using
         * [method`Gtk`.CheckButton.set_active], and retrieved using
         * [method`Gtk`.CheckButton.get_active].
         *
         * # Inconsistent state
         *
         * In addition to "on" and "off", check buttons can be an
         * "in between" state that is neither on nor off. This can be used
         * e.g. when the user has selected a range of elements (such as some
         * text or spreadsheet cells) that are affected by a check button,
         * and the current values in that range are inconsistent.
         *
         * To set a `GtkCheckButton` to inconsistent state, use
         * [method`Gtk`.CheckButton.set_inconsistent].
         *
         * # Grouping
         *
         * Check buttons can be grouped together, to form mutually exclusive
         * groups - only one of the buttons can be toggled at a time, and toggling
         * another one will switch the currently toggled one off.
         *
         * Grouped check buttons use a different indicator, and are commonly referred
         * to as *radio buttons*.
         *
         * ![Example GtkCheckButtons](radio-button.png)
         *
         * To add a `GtkCheckButton` to a group, use [method`Gtk`.CheckButton.set_group].
         *
         * When the code must keep track of the state of a group of radio buttons, it
         * is recommended to keep track of such state through a stateful
         * `GAction` with a target for each button. Using the `toggled` signals to keep
         * track of the group changes and state is discouraged.
         *
         * # Shortcuts and Gestures
         *
         * `GtkCheckButton` supports the following keyboard shortcuts:
         *
         * - <kbd>␣</kbd> or <kbd>Enter</kbd> activates the button.
         *
         * # CSS nodes
         *
         * ```
         * checkbutton[.text-button][.grouped]
         * ├── check
         * ╰── [label]
         * ```
         *
         * A `GtkCheckButton` has a main node with name checkbutton. If the
         * [property`Gtk`.CheckButton:label] or [property`Gtk`.CheckButton:child]
         * properties are set, it contains a child widget. The indicator node
         * is named check when no group is set, and radio if the checkbutton
         * is grouped together with other checkbuttons.
         *
         * # Accessibility
         *
         * `GtkCheckButton` uses the %GTK_ACCESSIBLE_ROLE_CHECKBOX role.
         */
        class CheckButton extends Widget implements Accessible, Actionable, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<CheckButton>;

            // Properties

            /**
             * If the check button is active.
             *
             * Setting `active` to %TRUE will add the `:checked:` state to both
             * the check button and the indicator CSS node.
             */
            get active(): boolean;
            set active(val: boolean);
            /**
             * The child widget.
             */
            get child(): Widget;
            set child(val: Widget);
            /**
             * The check button whose group this widget belongs to.
             */
            set group(val: CheckButton);
            /**
             * If the check button is in an “in between” state.
             *
             * The inconsistent state only affects visual appearance,
             * not the semantics of the button.
             */
            get inconsistent(): boolean;
            set inconsistent(val: boolean);
            /**
             * Text of the label inside the check button, if it contains a label widget.
             */
            get label(): string;
            set label(val: string);
            /**
             * If set, an underline in the text indicates that the following
             * character is to be used as mnemonic.
             */
            get use_underline(): boolean;
            set use_underline(val: boolean);
            /**
             * If set, an underline in the text indicates that the following
             * character is to be used as mnemonic.
             */
            get useUnderline(): boolean;
            set useUnderline(val: boolean);

            // Constructors

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

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

            static ['new'](): CheckButton;

            static new_with_label(label?: string | null): CheckButton;

            static new_with_mnemonic(label?: string | null): CheckButton;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate', callback: (_source: this) => void): number;
            connect_after(signal: 'activate', callback: (_source: this) => void): number;
            emit(signal: 'activate'): void;
            connect(signal: 'toggled', callback: (_source: this) => void): number;
            connect_after(signal: 'toggled', callback: (_source: this) => void): number;
            emit(signal: 'toggled'): void;

            // Virtual methods

            vfunc_activate(): void;
            vfunc_toggled(): void;

            // Methods

            /**
             * Returns whether the check button is active.
             * @returns whether the check button is active
             */
            get_active(): boolean;
            /**
             * Gets the child widget of `button` or `NULL` if [property`CheckButton:`label] is set.
             * @returns the child widget of @button
             */
            get_child(): Widget | null;
            /**
             * Returns whether the check button is in an inconsistent state.
             * @returns %TRUE if @check_button is currently in an inconsistent state
             */
            get_inconsistent(): boolean;
            /**
             * Returns the label of the check button or `NULL` if [property`CheckButton:`child] is set.
             * @returns The label @self shows next   to the indicator. If no label is shown, %NULL will be returned.
             */
            get_label(): string | null;
            /**
             * Returns whether underlines in the label indicate mnemonics.
             * @returns The value of the [property@Gtk.CheckButton:use-underline] property.   See [method@Gtk.CheckButton.set_use_underline] for details on how to set   a new value.
             */
            get_use_underline(): boolean;
            /**
             * Changes the check buttons active state.
             * @param setting the new value to set
             */
            set_active(setting: boolean): void;
            /**
             * Sets the child widget of `button`.
             *
             * Note that by using this API, you take full responsibility for setting
             * up the proper accessibility label and description information for `button`.
             * Most likely, you'll either set the accessibility label or description
             * for `button` explicitly, or you'll set a labelled-by or described-by
             * relations from `child` to `button`.
             * @param child the child widget
             */
            set_child(child?: Widget | null): void;
            /**
             * Adds `self` to the group of `group`.
             *
             * In a group of multiple check buttons, only one button can be active
             * at a time. The behavior of a checkbutton in a group is also commonly
             * known as a *radio button*.
             *
             * Setting the group of a check button also changes the css name of the
             * indicator widget's CSS node to 'radio'.
             *
             * Setting up groups in a cycle leads to undefined behavior.
             *
             * Note that the same effect can be achieved via the [iface`Gtk`.Actionable]
             * API, by using the same action with parameter type and state type 's'
             * for all buttons in the group, and giving each button its own target
             * value.
             * @param group another `GtkCheckButton` to   form a group with
             */
            set_group(group?: CheckButton | null): void;
            /**
             * Sets the `GtkCheckButton` to inconsistent state.
             *
             * You should turn off the inconsistent state again if the user checks
             * the check button. This has to be done manually.
             * @param inconsistent %TRUE if state is inconsistent
             */
            set_inconsistent(inconsistent: boolean): void;
            /**
             * Sets the text of `self`.
             *
             * If [property`Gtk`.CheckButton:use-underline] is %TRUE, an underscore
             * in `label` is interpreted as mnemonic indicator, see
             * [method`Gtk`.CheckButton.set_use_underline] for details on this behavior.
             * @param label The text shown next to the indicator, or %NULL   to show no text
             */
            set_label(label?: string | null): void;
            /**
             * Sets whether underlines in the label indicate mnemonics.
             *
             * If `setting` is %TRUE, an underscore character in `self'`s label
             * indicates a mnemonic accelerator key. This behavior is similar
             * to [property`Gtk`.Label:use-underline].
             * @param setting the new value to set
             */
            set_use_underline(setting: boolean): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The name of the action with which this widget should be associated.
             */
            get action_name(): string;
            set action_name(val: string);
            /**
             * The name of the action with which this widget should be associated.
             */
            get actionName(): string;
            set actionName(val: string);
            /**
             * The target value of the actionable widget's action.
             */
            get action_target(): GLib.Variant;
            set action_target(val: GLib.Variant);
            /**
             * The target value of the actionable widget's action.
             */
            get actionTarget(): GLib.Variant;
            set actionTarget(val: GLib.Variant);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the action name for `actionable`.
             * @returns the action name
             */
            get_action_name(): string | null;
            /**
             * Gets the current target value of `actionable`.
             * @returns the current target value
             */
            get_action_target_value(): GLib.Variant | null;
            /**
             * Specifies the name of the action with which this widget should be
             * associated.
             *
             * If `action_name` is %NULL then the widget will be unassociated from
             * any previous action.
             *
             * Usually this function is used when the widget is located (or will be
             * located) within the hierarchy of a `GtkApplicationWindow`.
             *
             * Names are of the form “win.save” or “app.quit” for actions on the
             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
             * associated with the window.
             * @param action_name an action name
             */
            set_action_name(action_name?: string | null): void;
            /**
             * Sets the target value of an actionable widget.
             *
             * If `target_value` is %NULL then the target value is unset.
             *
             * The target value has two purposes. First, it is used as the parameter
             * to activation of the action associated with the `GtkActionable` widget.
             * Second, it is used to determine if the widget should be rendered as
             * “active” — the widget is active if the state is equal to the given target.
             *
             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
             * with string state in a typical “radio button” situation. Each button
             * will be associated with the same action, but with a different target
             * value for that action. Clicking on a particular button will activate
             * the action with the target of that button, which will typically cause
             * the action’s state to change to that value. Since the action’s state
             * is now equal to the target value of the button, the button will now
             * be rendered as active (and the other buttons, with different targets,
             * rendered inactive).
             * @param target_value a [struct@GLib.Variant] to set as the target value
             */
            set_action_target_value(target_value?: GLib.Variant | null): void;
            /**
             * Sets the action-name and associated string target value of an
             * actionable widget.
             *
             * `detailed_action_name` is a string in the format accepted by
             * [func`Gio`.Action.parse_detailed_name].
             * @param detailed_action_name the detailed action name
             */
            set_detailed_action_name(detailed_action_name: string): void;
            /**
             * Gets the action name for `actionable`.
             */
            vfunc_get_action_name(): string | null;
            /**
             * Gets the current target value of `actionable`.
             */
            vfunc_get_action_target_value(): GLib.Variant | null;
            /**
             * Specifies the name of the action with which this widget should be
             * associated.
             *
             * If `action_name` is %NULL then the widget will be unassociated from
             * any previous action.
             *
             * Usually this function is used when the widget is located (or will be
             * located) within the hierarchy of a `GtkApplicationWindow`.
             *
             * Names are of the form “win.save” or “app.quit” for actions on the
             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
             * associated with the window.
             * @param action_name an action name
             */
            vfunc_set_action_name(action_name?: string | null): void;
            /**
             * Sets the target value of an actionable widget.
             *
             * If `target_value` is %NULL then the target value is unset.
             *
             * The target value has two purposes. First, it is used as the parameter
             * to activation of the action associated with the `GtkActionable` widget.
             * Second, it is used to determine if the widget should be rendered as
             * “active” — the widget is active if the state is equal to the given target.
             *
             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
             * with string state in a typical “radio button” situation. Each button
             * will be associated with the same action, but with a different target
             * value for that action. Clicking on a particular button will activate
             * the action with the target of that button, which will typically cause
             * the action’s state to change to that value. Since the action’s state
             * is now equal to the target value of the button, the button will now
             * be rendered as active (and the other buttons, with different targets,
             * rendered inactive).
             * @param target_value a [struct@GLib.Variant] to set as the target value
             */
            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        /**
         * An expression using a custom `GClosure` to compute the value from
         * its parameters.
         */
        class ClosureExpression extends Expression {
            static $gtype: GObject.GType<ClosureExpression>;

            // Constructors

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

            static ['new'](
                value_type: GObject.GType,
                closure: GObject.Closure,
                params?: Expression[] | null,
            ): ClosureExpression;
        }

        namespace ColorButton {
            // Signal callback interfaces

            interface Activate {
                (): void;
            }

            interface ColorSet {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ColorChooser.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                modal: boolean;
                show_editor: boolean;
                showEditor: boolean;
                title: string;
            }
        }

        /**
         * The `GtkColorButton` allows to open a color chooser dialog to change
         * the color.
         *
         * ![An example GtkColorButton](color-button.png)
         *
         * It is suitable widget for selecting a color in a preference dialog.
         *
         * # CSS nodes
         *
         * ```
         * colorbutton
         * ╰── button.color
         *     ╰── [content]
         * ```
         *
         * `GtkColorButton` has a single CSS node with name colorbutton which
         * contains a button node. To differentiate it from a plain `GtkButton`,
         * it gets the .color style class.
         */
        class ColorButton extends Widget implements Accessible, Buildable, ColorChooser, ConstraintTarget {
            static $gtype: GObject.GType<ColorButton>;

            // Properties

            /**
             * Whether the color chooser dialog should be modal.
             */
            get modal(): boolean;
            set modal(val: boolean);
            /**
             * Whether the color chooser should open in editor mode.
             *
             * This property should be used in cases where the palette
             * in the editor would be redundant, such as when the color
             * button is already part of a palette.
             */
            get show_editor(): boolean;
            set show_editor(val: boolean);
            /**
             * Whether the color chooser should open in editor mode.
             *
             * This property should be used in cases where the palette
             * in the editor would be redundant, such as when the color
             * button is already part of a palette.
             */
            get showEditor(): boolean;
            set showEditor(val: boolean);
            /**
             * The title of the color chooser dialog
             */
            get title(): string;
            set title(val: string);

            // Constructors

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

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

            static ['new'](): ColorButton;

            static new_with_rgba(rgba: Gdk.RGBA): ColorButton;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate', callback: (_source: this) => void): number;
            connect_after(signal: 'activate', callback: (_source: this) => void): number;
            emit(signal: 'activate'): void;
            connect(signal: 'color-set', callback: (_source: this) => void): number;
            connect_after(signal: 'color-set', callback: (_source: this) => void): number;
            emit(signal: 'color-set'): void;

            // Methods

            /**
             * Gets whether the dialog is modal.
             * @returns %TRUE if the dialog is modal
             */
            get_modal(): boolean;
            /**
             * Gets the title of the color chooser dialog.
             * @returns An internal string, do not free the return value
             */
            get_title(): string;
            /**
             * Sets whether the dialog should be modal.
             * @param modal %TRUE to make the dialog modal
             */
            set_modal(modal: boolean): void;
            /**
             * Sets the title for the color chooser dialog.
             * @param title String containing new window title
             */
            set_title(title: string): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The currently selected color, as a `GdkRGBA` struct.
             *
             * The property can be set to change the current selection
             * programmatically.
             */
            get rgba(): Gdk.RGBA;
            set rgba(val: Gdk.RGBA);
            /**
             * Whether colors may have alpha (translucency).
             *
             * When ::use-alpha is %FALSE, the `GdkRGBA` struct obtained
             * via the [property`Gtk`.ColorChooser:rgba] property will be
             * forced to have alpha == 1.
             *
             * Implementations are expected to show alpha by rendering the color
             * over a non-uniform background (like a checkerboard pattern).
             */
            get use_alpha(): boolean;
            set use_alpha(val: boolean);
            /**
             * Whether colors may have alpha (translucency).
             *
             * When ::use-alpha is %FALSE, the `GdkRGBA` struct obtained
             * via the [property`Gtk`.ColorChooser:rgba] property will be
             * forced to have alpha == 1.
             *
             * Implementations are expected to show alpha by rendering the color
             * over a non-uniform background (like a checkerboard pattern).
             */
            get useAlpha(): boolean;
            set useAlpha(val: boolean);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Adds a palette to the color chooser.
             *
             * If `orientation` is horizontal, the colors are grouped in rows,
             * with `colors_per_line` colors in each row. If `horizontal` is %FALSE,
             * the colors are grouped in columns instead.
             *
             * The default color palette of [class`Gtk`.ColorChooserWidget] has
             * 45 colors, organized in columns of 5 colors (this includes some
             * grays).
             *
             * The layout of the color chooser widget works best when the
             * palettes have 9-10 columns.
             *
             * Calling this function for the first time has the side effect
             * of removing the default color palette from the color chooser.
             *
             * If `colors` is %NULL, removes all previously added palettes.
             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should   be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
             * @param colors_per_line the number of colors to show in each row/column
             * @param colors the colors of the palette
             */
            add_palette(orientation: Orientation | null, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
            /**
             * Gets the currently-selected color.
             */
            get_rgba(): Gdk.RGBA;
            /**
             * Returns whether the color chooser shows the alpha channel.
             * @returns %TRUE if the color chooser uses the alpha channel,   %FALSE if not
             */
            get_use_alpha(): boolean;
            /**
             * Sets the color.
             * @param color the new color
             */
            set_rgba(color: Gdk.RGBA): void;
            /**
             * Sets whether or not the color chooser should use the alpha channel.
             * @param use_alpha %TRUE if color chooser should use alpha channel, %FALSE if not
             */
            set_use_alpha(use_alpha: boolean): void;
            /**
             * Adds a palette to the color chooser.
             *
             * If `orientation` is horizontal, the colors are grouped in rows,
             * with `colors_per_line` colors in each row. If `horizontal` is %FALSE,
             * the colors are grouped in columns instead.
             *
             * The default color palette of [class`Gtk`.ColorChooserWidget] has
             * 45 colors, organized in columns of 5 colors (this includes some
             * grays).
             *
             * The layout of the color chooser widget works best when the
             * palettes have 9-10 columns.
             *
             * Calling this function for the first time has the side effect
             * of removing the default color palette from the color chooser.
             *
             * If `colors` is %NULL, removes all previously added palettes.
             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should   be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
             * @param colors_per_line the number of colors to show in each row/column
             * @param colors the colors of the palette
             */
            vfunc_add_palette(orientation: Orientation, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
            vfunc_color_activated(color: Gdk.RGBA): void;
            /**
             * Gets the currently-selected color.
             */
            vfunc_get_rgba(): Gdk.RGBA;
            /**
             * Sets the color.
             * @param color the new color
             */
            vfunc_set_rgba(color: Gdk.RGBA): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ColorChooserDialog {
            // Constructor properties interface

            interface ConstructorProps
                extends Dialog.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ColorChooser.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Native.ConstructorProps,
                    Root.ConstructorProps,
                    ShortcutManager.ConstructorProps {
                show_editor: boolean;
                showEditor: boolean;
            }
        }

        /**
         * A dialog for choosing a color.
         *
         * ![An example GtkColorChooserDialog](colorchooser.png)
         *
         * `GtkColorChooserDialog` implements the [iface`Gtk`.ColorChooser] interface
         * and does not provide much API of its own.
         *
         * To create a `GtkColorChooserDialog`, use [ctor`Gtk`.ColorChooserDialog.new].
         *
         * To change the initially selected color, use
         * [method`Gtk`.ColorChooser.set_rgba]. To get the selected color use
         * [method`Gtk`.ColorChooser.get_rgba].
         *
         * `GtkColorChooserDialog` has been deprecated in favor of [class`Gtk`.ColorDialog].
         *
         * ## CSS nodes
         *
         * `GtkColorChooserDialog` has a single CSS node with the name `window` and style
         * class `.colorchooser`.
         */
        class ColorChooserDialog
            extends Dialog
            implements Accessible, Buildable, ColorChooser, ConstraintTarget, Native, Root, ShortcutManager
        {
            static $gtype: GObject.GType<ColorChooserDialog>;

            // Properties

            /**
             * Whether the color chooser dialog is showing the single-color editor.
             *
             * It can be set to switch the color chooser into single-color editing mode.
             */
            get show_editor(): boolean;
            set show_editor(val: boolean);
            /**
             * Whether the color chooser dialog is showing the single-color editor.
             *
             * It can be set to switch the color chooser into single-color editing mode.
             */
            get showEditor(): boolean;
            set showEditor(val: boolean);

            // Constructors

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

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

            static ['new'](title?: string | null, parent?: Window | null): ColorChooserDialog;
            // Conflicted with Gtk.Dialog.new

            static ['new'](...args: never[]): any;

            // Inherited properties
            /**
             * The currently selected color, as a `GdkRGBA` struct.
             *
             * The property can be set to change the current selection
             * programmatically.
             */
            get rgba(): Gdk.RGBA;
            set rgba(val: Gdk.RGBA);
            /**
             * Whether colors may have alpha (translucency).
             *
             * When ::use-alpha is %FALSE, the `GdkRGBA` struct obtained
             * via the [property`Gtk`.ColorChooser:rgba] property will be
             * forced to have alpha == 1.
             *
             * Implementations are expected to show alpha by rendering the color
             * over a non-uniform background (like a checkerboard pattern).
             */
            get use_alpha(): boolean;
            set use_alpha(val: boolean);
            /**
             * Whether colors may have alpha (translucency).
             *
             * When ::use-alpha is %FALSE, the `GdkRGBA` struct obtained
             * via the [property`Gtk`.ColorChooser:rgba] property will be
             * forced to have alpha == 1.
             *
             * Implementations are expected to show alpha by rendering the color
             * over a non-uniform background (like a checkerboard pattern).
             */
            get useAlpha(): boolean;
            set useAlpha(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Adds a palette to the color chooser.
             *
             * If `orientation` is horizontal, the colors are grouped in rows,
             * with `colors_per_line` colors in each row. If `horizontal` is %FALSE,
             * the colors are grouped in columns instead.
             *
             * The default color palette of [class`Gtk`.ColorChooserWidget] has
             * 45 colors, organized in columns of 5 colors (this includes some
             * grays).
             *
             * The layout of the color chooser widget works best when the
             * palettes have 9-10 columns.
             *
             * Calling this function for the first time has the side effect
             * of removing the default color palette from the color chooser.
             *
             * If `colors` is %NULL, removes all previously added palettes.
             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should   be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
             * @param colors_per_line the number of colors to show in each row/column
             * @param colors the colors of the palette
             */
            add_palette(orientation: Orientation | null, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
            /**
             * Gets the currently-selected color.
             */
            get_rgba(): Gdk.RGBA;
            /**
             * Returns whether the color chooser shows the alpha channel.
             * @returns %TRUE if the color chooser uses the alpha channel,   %FALSE if not
             */
            get_use_alpha(): boolean;
            /**
             * Sets the color.
             * @param color the new color
             */
            set_rgba(color: Gdk.RGBA): void;
            /**
             * Sets whether or not the color chooser should use the alpha channel.
             * @param use_alpha %TRUE if color chooser should use alpha channel, %FALSE if not
             */
            set_use_alpha(use_alpha: boolean): void;
            /**
             * Adds a palette to the color chooser.
             *
             * If `orientation` is horizontal, the colors are grouped in rows,
             * with `colors_per_line` colors in each row. If `horizontal` is %FALSE,
             * the colors are grouped in columns instead.
             *
             * The default color palette of [class`Gtk`.ColorChooserWidget] has
             * 45 colors, organized in columns of 5 colors (this includes some
             * grays).
             *
             * The layout of the color chooser widget works best when the
             * palettes have 9-10 columns.
             *
             * Calling this function for the first time has the side effect
             * of removing the default color palette from the color chooser.
             *
             * If `colors` is %NULL, removes all previously added palettes.
             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should   be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
             * @param colors_per_line the number of colors to show in each row/column
             * @param colors the colors of the palette
             */
            vfunc_add_palette(orientation: Orientation, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
            vfunc_color_activated(color: Gdk.RGBA): void;
            /**
             * Gets the currently-selected color.
             */
            vfunc_get_rgba(): Gdk.RGBA;
            /**
             * Sets the color.
             * @param color the new color
             */
            vfunc_set_rgba(color: Gdk.RGBA): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace ColorChooserWidget {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ColorChooser.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                show_editor: boolean;
                showEditor: boolean;
            }
        }

        /**
         * The `GtkColorChooserWidget` widget lets the user select a color.
         *
         * By default, the chooser presents a predefined palette of colors,
         * plus a small number of settable custom colors. It is also possible
         * to select a different color with the single-color editor.
         *
         * To enter the single-color editing mode, use the context menu of any
         * color of the palette, or use the '+' button to add a new custom color.
         *
         * The chooser automatically remembers the last selection, as well
         * as custom colors.
         *
         * To create a `GtkColorChooserWidget`, use [ctor`Gtk`.ColorChooserWidget.new].
         *
         * To change the initially selected color, use
         * [method`Gtk`.ColorChooser.set_rgba]. To get the selected color use
         * [method`Gtk`.ColorChooser.get_rgba].
         *
         * The `GtkColorChooserWidget` is used in the [class`Gtk`.ColorChooserDialog]
         * to provide a dialog for selecting colors.
         *
         * # Actions
         *
         * `GtkColorChooserWidget` defines a set of built-in actions:
         *
         * - `color.customize` activates the color editor for the given color.
         * - `color.select` emits the [signal`Gtk`.ColorChooser::color-activated] signal
         *   for the given color.
         *
         * # CSS names
         *
         * `GtkColorChooserWidget` has a single CSS node with name colorchooser.
         */
        class ColorChooserWidget extends Widget implements Accessible, Buildable, ColorChooser, ConstraintTarget {
            static $gtype: GObject.GType<ColorChooserWidget>;

            // Properties

            /**
             * %TRUE when the color chooser is showing the single-color editor.
             *
             * It can be set to switch the color chooser into single-color editing mode.
             */
            get show_editor(): boolean;
            set show_editor(val: boolean);
            /**
             * %TRUE when the color chooser is showing the single-color editor.
             *
             * It can be set to switch the color chooser into single-color editing mode.
             */
            get showEditor(): boolean;
            set showEditor(val: boolean);

            // Constructors

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

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

            static ['new'](): ColorChooserWidget;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The currently selected color, as a `GdkRGBA` struct.
             *
             * The property can be set to change the current selection
             * programmatically.
             */
            get rgba(): Gdk.RGBA;
            set rgba(val: Gdk.RGBA);
            /**
             * Whether colors may have alpha (translucency).
             *
             * When ::use-alpha is %FALSE, the `GdkRGBA` struct obtained
             * via the [property`Gtk`.ColorChooser:rgba] property will be
             * forced to have alpha == 1.
             *
             * Implementations are expected to show alpha by rendering the color
             * over a non-uniform background (like a checkerboard pattern).
             */
            get use_alpha(): boolean;
            set use_alpha(val: boolean);
            /**
             * Whether colors may have alpha (translucency).
             *
             * When ::use-alpha is %FALSE, the `GdkRGBA` struct obtained
             * via the [property`Gtk`.ColorChooser:rgba] property will be
             * forced to have alpha == 1.
             *
             * Implementations are expected to show alpha by rendering the color
             * over a non-uniform background (like a checkerboard pattern).
             */
            get useAlpha(): boolean;
            set useAlpha(val: boolean);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Adds a palette to the color chooser.
             *
             * If `orientation` is horizontal, the colors are grouped in rows,
             * with `colors_per_line` colors in each row. If `horizontal` is %FALSE,
             * the colors are grouped in columns instead.
             *
             * The default color palette of [class`Gtk`.ColorChooserWidget] has
             * 45 colors, organized in columns of 5 colors (this includes some
             * grays).
             *
             * The layout of the color chooser widget works best when the
             * palettes have 9-10 columns.
             *
             * Calling this function for the first time has the side effect
             * of removing the default color palette from the color chooser.
             *
             * If `colors` is %NULL, removes all previously added palettes.
             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should   be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
             * @param colors_per_line the number of colors to show in each row/column
             * @param colors the colors of the palette
             */
            add_palette(orientation: Orientation | null, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
            /**
             * Gets the currently-selected color.
             */
            get_rgba(): Gdk.RGBA;
            /**
             * Returns whether the color chooser shows the alpha channel.
             * @returns %TRUE if the color chooser uses the alpha channel,   %FALSE if not
             */
            get_use_alpha(): boolean;
            /**
             * Sets the color.
             * @param color the new color
             */
            set_rgba(color: Gdk.RGBA): void;
            /**
             * Sets whether or not the color chooser should use the alpha channel.
             * @param use_alpha %TRUE if color chooser should use alpha channel, %FALSE if not
             */
            set_use_alpha(use_alpha: boolean): void;
            /**
             * Adds a palette to the color chooser.
             *
             * If `orientation` is horizontal, the colors are grouped in rows,
             * with `colors_per_line` colors in each row. If `horizontal` is %FALSE,
             * the colors are grouped in columns instead.
             *
             * The default color palette of [class`Gtk`.ColorChooserWidget] has
             * 45 colors, organized in columns of 5 colors (this includes some
             * grays).
             *
             * The layout of the color chooser widget works best when the
             * palettes have 9-10 columns.
             *
             * Calling this function for the first time has the side effect
             * of removing the default color palette from the color chooser.
             *
             * If `colors` is %NULL, removes all previously added palettes.
             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should   be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
             * @param colors_per_line the number of colors to show in each row/column
             * @param colors the colors of the palette
             */
            vfunc_add_palette(orientation: Orientation, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
            vfunc_color_activated(color: Gdk.RGBA): void;
            /**
             * Gets the currently-selected color.
             */
            vfunc_get_rgba(): Gdk.RGBA;
            /**
             * Sets the color.
             * @param color the new color
             */
            vfunc_set_rgba(color: Gdk.RGBA): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ColorDialog {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                modal: boolean;
                title: string;
                with_alpha: boolean;
                withAlpha: boolean;
            }
        }

        /**
         * A `GtkColorDialog` object collects the arguments that
         * are needed to present a color chooser dialog to the
         * user, such as a title for the dialog and whether it
         * should be modal.
         *
         * The dialog is shown with the [method`Gtk`.ColorDialog.choose_rgba]
         * function.
         *
         * See [class`Gtk`.ColorDialogButton] for a convenient control
         * that uses `GtkColorDialog` and presents the results.
         */
        class ColorDialog extends GObject.Object {
            static $gtype: GObject.GType<ColorDialog>;

            // Properties

            /**
             * Whether the color chooser dialog is modal.
             */
            get modal(): boolean;
            set modal(val: boolean);
            /**
             * A title that may be shown on the color chooser
             * dialog that is presented by [method`Gtk`.ColorDialog.choose_rgba].
             */
            get title(): string;
            set title(val: string);
            /**
             * Whether colors may have alpha (translucency).
             *
             * When with-alpha is %FALSE, the color that is selected
             * will be forced to have alpha == 1.
             */
            get with_alpha(): boolean;
            set with_alpha(val: boolean);
            /**
             * Whether colors may have alpha (translucency).
             *
             * When with-alpha is %FALSE, the color that is selected
             * will be forced to have alpha == 1.
             */
            get withAlpha(): boolean;
            set withAlpha(val: boolean);

            // Constructors

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

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

            static ['new'](): ColorDialog;

            // Methods

            /**
             * This function initiates a color choice operation by
             * presenting a color chooser dialog to the user.
             * @param parent the parent `GtkWindow`
             * @param initial_color the color to select initially
             * @param cancellable a `GCancellable` to cancel the operation
             */
            choose_rgba(
                parent?: Window | null,
                initial_color?: Gdk.RGBA | null,
                cancellable?: Gio.Cancellable | null,
            ): Promise<Gdk.RGBA | null>;
            /**
             * This function initiates a color choice operation by
             * presenting a color chooser dialog to the user.
             * @param parent the parent `GtkWindow`
             * @param initial_color the color to select initially
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            choose_rgba(
                parent: Window | null,
                initial_color: Gdk.RGBA | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * This function initiates a color choice operation by
             * presenting a color chooser dialog to the user.
             * @param parent the parent `GtkWindow`
             * @param initial_color the color to select initially
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            choose_rgba(
                parent?: Window | null,
                initial_color?: Gdk.RGBA | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<Gdk.RGBA | null> | void;
            /**
             * Finishes the [method`Gtk`.ColorDialog.choose_rgba] call and
             * returns the resulting color.
             * @param result a `GAsyncResult`
             * @returns the selected color, or   `NULL` and @error is set
             */
            choose_rgba_finish(result: Gio.AsyncResult): Gdk.RGBA | null;
            /**
             * Returns whether the color chooser dialog
             * blocks interaction with the parent window
             * while it is presented.
             * @returns `TRUE` if the color chooser dialog is modal
             */
            get_modal(): boolean;
            /**
             * Returns the title that will be shown on the
             * color chooser dialog.
             * @returns the title
             */
            get_title(): string;
            /**
             * Returns whether colors may have alpha.
             * @returns `TRUE` if colors may have alpha
             */
            get_with_alpha(): boolean;
            /**
             * Sets whether the color chooser dialog
             * blocks interaction with the parent window
             * while it is presented.
             * @param modal the new value
             */
            set_modal(modal: boolean): void;
            /**
             * Sets the title that will be shown on the
             * color chooser dialog.
             * @param title the new title
             */
            set_title(title: string): void;
            /**
             * Sets whether colors may have alpha.
             * @param with_alpha the new value
             */
            set_with_alpha(with_alpha: boolean): void;
        }

        namespace ColorDialogButton {
            // Signal callback interfaces

            interface Activate {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                dialog: ColorDialog;
                rgba: Gdk.RGBA;
            }
        }

        /**
         * The `GtkColorDialogButton` is a wrapped around a [class`Gtk`.ColorDialog]
         * and allows to open a color chooser dialog to change the color.
         *
         * ![An example GtkColorDialogButton](color-button.png)
         *
         * It is suitable widget for selecting a color in a preference dialog.
         *
         * # CSS nodes
         *
         * ```
         * colorbutton
         * ╰── button.color
         *     ╰── [content]
         * ```
         *
         * `GtkColorDialogButton` has a single CSS node with name colorbutton which
         * contains a button node. To differentiate it from a plain `GtkButton`,
         * it gets the .color style class.
         */
        class ColorDialogButton extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<ColorDialogButton>;

            // Properties

            /**
             * The `GtkColorDialog` that contains parameters for
             * the color chooser dialog.
             */
            get dialog(): ColorDialog;
            set dialog(val: ColorDialog);
            /**
             * The selected color.
             *
             * This property can be set to give the button its initial
             * color, and it will be updated to reflect the users choice
             * in the color chooser dialog.
             *
             * Listen to `notify::rgba` to get informed about changes
             * to the buttons color.
             */
            get rgba(): Gdk.RGBA;
            set rgba(val: Gdk.RGBA);

            // Constructors

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

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

            static ['new'](dialog?: ColorDialog | null): ColorDialogButton;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate', callback: (_source: this) => void): number;
            connect_after(signal: 'activate', callback: (_source: this) => void): number;
            emit(signal: 'activate'): void;

            // Methods

            /**
             * Returns the `GtkColorDialog` of `self`.
             * @returns the `GtkColorDialog`
             */
            get_dialog(): ColorDialog | null;
            /**
             * Returns the color of the button.
             *
             * This function is what should be used to obtain
             * the color that was chosen by the user. To get
             * informed about changes, listen to "notify::rgba".
             * @returns the color
             */
            get_rgba(): Gdk.RGBA;
            /**
             * Sets a `GtkColorDialog` object to use for
             * creating the color chooser dialog that is
             * presented when the user clicks the button.
             * @param dialog the new `GtkColorDialog`
             */
            set_dialog(dialog: ColorDialog): void;
            /**
             * Sets the color of the button.
             * @param color the new color
             */
            set_rgba(color: Gdk.RGBA): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ColumnView {
            // Signal callback interfaces

            interface Activate {
                (position: number): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Scrollable.ConstructorProps {
                columns: Gio.ListModel;
                enable_rubberband: boolean;
                enableRubberband: boolean;
                header_factory: ListItemFactory;
                headerFactory: ListItemFactory;
                model: SelectionModel;
                reorderable: boolean;
                row_factory: ListItemFactory;
                rowFactory: ListItemFactory;
                show_column_separators: boolean;
                showColumnSeparators: boolean;
                show_row_separators: boolean;
                showRowSeparators: boolean;
                single_click_activate: boolean;
                singleClickActivate: boolean;
                sorter: Sorter;
                tab_behavior: ListTabBehavior;
                tabBehavior: ListTabBehavior;
            }
        }

        /**
         * `GtkColumnView` presents a large dynamic list of items using multiple columns
         * with headers.
         *
         * `GtkColumnView` uses the factories of its columns to generate a cell widget for
         * each column, for each visible item and displays them together as the row for
         * this item.
         *
         * The [property`Gtk`.ColumnView:show-row-separators] and
         * [property`Gtk`.ColumnView:show-column-separators] properties offer a simple way
         * to display separators between the rows or columns.
         *
         * `GtkColumnView` allows the user to select items according to the selection
         * characteristics of the model. For models that allow multiple selected items,
         * it is possible to turn on *rubberband selection*, using
         * [property`Gtk`.ColumnView:enable-rubberband].
         *
         * The column view supports sorting that can be customized by the user by
         * clicking on column headers. To set this up, the `GtkSorter` returned by
         * [method`Gtk`.ColumnView.get_sorter] must be attached to a sort model for the
         * data that the view is showing, and the columns must have sorters attached to
         * them by calling [method`Gtk`.ColumnViewColumn.set_sorter]. The initial sort
         * order can be set with [method`Gtk`.ColumnView.sort_by_column].
         *
         * The column view also supports interactive resizing and reordering of
         * columns, via Drag-and-Drop of the column headers. This can be enabled or
         * disabled with the [property`Gtk`.ColumnView:reorderable] and
         * [property`Gtk`.ColumnViewColumn:resizable] properties.
         *
         * To learn more about the list widget framework, see the
         * [overview](section-list-widget.html).
         *
         * # CSS nodes
         *
         * ```
         * columnview[.column-separators][.rich-list][.navigation-sidebar][.data-table]
         * ├── header
         * │   ├── <column header>
         * ┊   ┊
         * │   ╰── <column header>
         * │
         * ├── listview
         * │
         * ┊
         * ╰── [rubberband]
         * ```
         *
         * `GtkColumnView` uses a single CSS node named columnview. It may carry the
         * .column-separators style class, when [property`Gtk`.ColumnView:show-column-separators]
         * property is set. Header widgets appear below a node with name header.
         * The rows are contained in a `GtkListView` widget, so there is a listview
         * node with the same structure as for a standalone `GtkListView` widget.
         * If [property`Gtk`.ColumnView:show-row-separators] is set, it will be passed
         * on to the list view, causing its CSS node to carry the .separators style class.
         * For rubberband selection, a node with name rubberband is used.
         *
         * The main columnview node may also carry style classes to select
         * the style of [list presentation](section-list-widget.html#list-styles):
         * .rich-list, .navigation-sidebar or .data-table.
         *
         * # Accessibility
         *
         * `GtkColumnView` uses the %GTK_ACCESSIBLE_ROLE_TREE_GRID role, header title
         * widgets are using the %GTK_ACCESSIBLE_ROLE_COLUMN_HEADER role. The row widgets
         * are using the %GTK_ACCESSIBLE_ROLE_ROW role, and individual cells are using
         * the %GTK_ACCESSIBLE_ROLE_GRID_CELL role
         */
        class ColumnView extends Widget implements Accessible, Buildable, ConstraintTarget, Scrollable {
            static $gtype: GObject.GType<ColumnView>;

            // Properties

            /**
             * The list of columns.
             */
            get columns(): Gio.ListModel;
            /**
             * Allow rubberband selection.
             */
            get enable_rubberband(): boolean;
            set enable_rubberband(val: boolean);
            /**
             * Allow rubberband selection.
             */
            get enableRubberband(): boolean;
            set enableRubberband(val: boolean);
            /**
             * Factory for creating header widgets.
             *
             * The factory must be for configuring [class`Gtk`.ListHeader] objects.
             */
            get header_factory(): ListItemFactory;
            set header_factory(val: ListItemFactory);
            /**
             * Factory for creating header widgets.
             *
             * The factory must be for configuring [class`Gtk`.ListHeader] objects.
             */
            get headerFactory(): ListItemFactory;
            set headerFactory(val: ListItemFactory);
            /**
             * Model for the items displayed.
             */
            get model(): SelectionModel;
            set model(val: SelectionModel);
            /**
             * Whether columns are reorderable.
             */
            get reorderable(): boolean;
            set reorderable(val: boolean);
            /**
             * The factory used for configuring rows.
             *
             * The factory must be for configuring [class`Gtk`.ColumnViewRow] objects.
             */
            get row_factory(): ListItemFactory;
            set row_factory(val: ListItemFactory);
            /**
             * The factory used for configuring rows.
             *
             * The factory must be for configuring [class`Gtk`.ColumnViewRow] objects.
             */
            get rowFactory(): ListItemFactory;
            set rowFactory(val: ListItemFactory);
            /**
             * Show separators between columns.
             */
            get show_column_separators(): boolean;
            set show_column_separators(val: boolean);
            /**
             * Show separators between columns.
             */
            get showColumnSeparators(): boolean;
            set showColumnSeparators(val: boolean);
            /**
             * Show separators between rows.
             */
            get show_row_separators(): boolean;
            set show_row_separators(val: boolean);
            /**
             * Show separators between rows.
             */
            get showRowSeparators(): boolean;
            set showRowSeparators(val: boolean);
            /**
             * Activate rows on single click and select them on hover.
             */
            get single_click_activate(): boolean;
            set single_click_activate(val: boolean);
            /**
             * Activate rows on single click and select them on hover.
             */
            get singleClickActivate(): boolean;
            set singleClickActivate(val: boolean);
            /**
             * Sorter with the sorting choices of the user.
             */
            get sorter(): Sorter;
            /**
             * Behavior of the <kbd>Tab</kbd> key
             */
            get tab_behavior(): ListTabBehavior;
            set tab_behavior(val: ListTabBehavior);
            /**
             * Behavior of the <kbd>Tab</kbd> key
             */
            get tabBehavior(): ListTabBehavior;
            set tabBehavior(val: ListTabBehavior);

            // Constructors

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

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

            static ['new'](model?: SelectionModel | null): ColumnView;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate', callback: (_source: this, position: number) => void): number;
            connect_after(signal: 'activate', callback: (_source: this, position: number) => void): number;
            emit(signal: 'activate', position: number): void;

            // Methods

            /**
             * Appends the `column` to the end of the columns in `self`.
             * @param column a `GtkColumnViewColumn` that hasn't been added to a   `GtkColumnView` yet
             */
            append_column(column: ColumnViewColumn): void;
            /**
             * Gets the list of columns in this column view.
             *
             * This list is constant over the lifetime of `self` and can be used to
             * monitor changes to the columns of `self` by connecting to the
             * ::items-changed signal.
             * @returns The list managing the columns
             */
            get_columns(): Gio.ListModel;
            /**
             * Returns whether rows can be selected by dragging with the mouse.
             * @returns %TRUE if rubberband selection is enabled
             */
            get_enable_rubberband(): boolean;
            /**
             * Gets the factory that's currently used to populate section headers.
             * @returns The factory in use
             */
            get_header_factory(): ListItemFactory | null;
            /**
             * Gets the model that's currently used to read the items displayed.
             * @returns The model in use
             */
            get_model(): SelectionModel | null;
            /**
             * Returns whether columns are reorderable.
             * @returns %TRUE if columns are reorderable
             */
            get_reorderable(): boolean;
            /**
             * Gets the factory set via [method`Gtk`.ColumnView.set_row_factory].
             * @returns The factory
             */
            get_row_factory(): ListItemFactory | null;
            /**
             * Returns whether the list should show separators
             * between columns.
             * @returns %TRUE if the list shows column separators
             */
            get_show_column_separators(): boolean;
            /**
             * Returns whether the list should show separators
             * between rows.
             * @returns %TRUE if the list shows separators
             */
            get_show_row_separators(): boolean;
            /**
             * Returns whether rows will be activated on single click and
             * selected on hover.
             * @returns %TRUE if rows are activated on single click
             */
            get_single_click_activate(): boolean;
            /**
             * Returns a special sorter that reflects the users sorting
             * choices in the column view.
             *
             * To allow users to customizable sorting by clicking on column
             * headers, this sorter needs to be set on the sort model underneath
             * the model that is displayed by the view.
             *
             * See [method`Gtk`.ColumnViewColumn.set_sorter] for setting up
             * per-column sorting.
             *
             * Here is an example:
             * ```c
             * gtk_column_view_column_set_sorter (column, sorter);
             * gtk_column_view_append_column (view, column);
             * sorter = g_object_ref (gtk_column_view_get_sorter (view)));
             * model = gtk_sort_list_model_new (store, sorter);
             * selection = gtk_no_selection_new (model);
             * gtk_column_view_set_model (view, selection);
             * ```
             * @returns the `GtkSorter` of @self
             */
            get_sorter(): Sorter | null;
            /**
             * Gets the behavior set for the <kbd>Tab</kbd> key.
             * @returns The behavior of the <kbd>Tab</kbd> key
             */
            get_tab_behavior(): ListTabBehavior;
            /**
             * Inserts a column at the given position in the columns of `self`.
             *
             * If `column` is already a column of `self,` it will be repositioned.
             * @param position the position to insert @column at
             * @param column the `GtkColumnViewColumn` to insert
             */
            insert_column(position: number, column: ColumnViewColumn): void;
            /**
             * Removes the `column` from the list of columns of `self`.
             * @param column a `GtkColumnViewColumn` that's part of @self
             */
            remove_column(column: ColumnViewColumn): void;
            /**
             * Scroll to the row at the given position - or cell if a column is
             * given - and performs the actions specified in `flags`.
             *
             * This function works no matter if the listview is shown or focused.
             * If it isn't, then the changes will take effect once that happens.
             * @param pos position of the item. Must be less than the number of   items in the view.
             * @param column The column to scroll to   or %NULL to not scroll columns.
             * @param flags actions to perform
             * @param scroll details of how to perform   the scroll operation or %NULL to scroll into view
             */
            scroll_to(
                pos: number,
                column: ColumnViewColumn | null,
                flags: ListScrollFlags | null,
                scroll?: ScrollInfo | null,
            ): void;
            /**
             * Sets whether selections can be changed by dragging with the mouse.
             * @param enable_rubberband %TRUE to enable rubberband selection
             */
            set_enable_rubberband(enable_rubberband: boolean): void;
            /**
             * Sets the `GtkListItemFactory` to use for populating the
             * [class`Gtk`.ListHeader] objects used in section headers.
             *
             * If this factory is set to %NULL, the list will not show
             * section headers.
             * @param factory the factory to use
             */
            set_header_factory(factory?: ListItemFactory | null): void;
            /**
             * Sets the model to use.
             *
             * This must be a [iface`Gtk`.SelectionModel].
             * @param model the model to use
             */
            set_model(model?: SelectionModel | null): void;
            /**
             * Sets whether columns should be reorderable by dragging.
             * @param reorderable whether columns should be reorderable
             */
            set_reorderable(reorderable: boolean): void;
            /**
             * Sets the factory used for configuring rows. The factory must be for configuring
             * [class`Gtk`.ColumnViewRow] objects.
             *
             * If this factory is not set - which is the default - then the defaults will be used.
             *
             * This factory is not used to set the widgets displayed in the individual cells. For
             * that see [method`GtkColumnViewColumn`.set_factory] and [class`GtkColumnViewCell]`.
             * @param factory The row factory
             */
            set_row_factory(factory?: ListItemFactory | null): void;
            /**
             * Sets whether the list should show separators
             * between columns.
             * @param show_column_separators %TRUE to show column separators
             */
            set_show_column_separators(show_column_separators: boolean): void;
            /**
             * Sets whether the list should show separators
             * between rows.
             * @param show_row_separators %TRUE to show row separators
             */
            set_show_row_separators(show_row_separators: boolean): void;
            /**
             * Sets whether rows should be activated on single click and
             * selected on hover.
             * @param single_click_activate %TRUE to activate items on single click
             */
            set_single_click_activate(single_click_activate: boolean): void;
            /**
             * Sets the behavior of the <kbd>Tab</kbd> and <kbd>Shift</kbd>+<kbd>Tab</kbd> keys.
             * @param tab_behavior The desired tab behavior
             */
            set_tab_behavior(tab_behavior: ListTabBehavior | null): void;
            /**
             * Sets the sorting of the view.
             *
             * This function should be used to set up the initial sorting.
             * At runtime, users can change the sorting of a column view
             * by clicking on the list headers.
             *
             * This call only has an effect if the sorter returned by
             * [method`Gtk`.ColumnView.get_sorter] is set on a sort model,
             * and [method`Gtk`.ColumnViewColumn.set_sorter] has been called
             * on `column` to associate a sorter with the column.
             *
             * If `column` is %NULL, the view will be unsorted.
             * @param column the `GtkColumnViewColumn` to sort by
             * @param direction the direction to sort in
             */
            sort_by_column(column: ColumnViewColumn | null, direction: SortType | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * Horizontal `GtkAdjustment` of the scrollable widget.
             *
             * This adjustment is shared between the scrollable widget and its parent.
             */
            get hadjustment(): Adjustment;
            set hadjustment(val: Adjustment);
            /**
             * Determines when horizontal scrolling should start.
             */
            get hscroll_policy(): ScrollablePolicy;
            set hscroll_policy(val: ScrollablePolicy);
            /**
             * Determines when horizontal scrolling should start.
             */
            get hscrollPolicy(): ScrollablePolicy;
            set hscrollPolicy(val: ScrollablePolicy);
            /**
             * Vertical `GtkAdjustment` of the scrollable widget.
             *
             * This adjustment is shared between the scrollable widget and its parent.
             */
            get vadjustment(): Adjustment;
            set vadjustment(val: Adjustment);
            /**
             * Determines when vertical scrolling should start.
             */
            get vscroll_policy(): ScrollablePolicy;
            set vscroll_policy(val: ScrollablePolicy);
            /**
             * Determines when vertical scrolling should start.
             */
            get vscrollPolicy(): ScrollablePolicy;
            set vscrollPolicy(val: ScrollablePolicy);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Returns the size of a non-scrolling border around the
             * outside of the scrollable.
             *
             * An example for this would be treeview headers. GTK can use
             * this information to display overlaid graphics, like the
             * overshoot indication, at the right position.
             * @returns %TRUE if @border has been set
             */
            get_border(): [boolean, Border];
            /**
             * Retrieves the `GtkAdjustment` used for horizontal scrolling.
             * @returns horizontal `GtkAdjustment`.
             */
            get_hadjustment(): Adjustment | null;
            /**
             * Gets the horizontal `GtkScrollablePolicy`.
             * @returns The horizontal `GtkScrollablePolicy`.
             */
            get_hscroll_policy(): ScrollablePolicy;
            /**
             * Retrieves the `GtkAdjustment` used for vertical scrolling.
             * @returns vertical `GtkAdjustment`.
             */
            get_vadjustment(): Adjustment | null;
            /**
             * Gets the vertical `GtkScrollablePolicy`.
             * @returns The vertical `GtkScrollablePolicy`.
             */
            get_vscroll_policy(): ScrollablePolicy;
            /**
             * Sets the horizontal adjustment of the `GtkScrollable`.
             * @param hadjustment a `GtkAdjustment`
             */
            set_hadjustment(hadjustment?: Adjustment | null): void;
            /**
             * Sets the `GtkScrollablePolicy`.
             *
             * The policy determines whether horizontal scrolling should start
             * below the minimum width or below the natural width.
             * @param policy the horizontal `GtkScrollablePolicy`
             */
            set_hscroll_policy(policy: ScrollablePolicy | null): void;
            /**
             * Sets the vertical adjustment of the `GtkScrollable`.
             * @param vadjustment a `GtkAdjustment`
             */
            set_vadjustment(vadjustment?: Adjustment | null): void;
            /**
             * Sets the `GtkScrollablePolicy`.
             *
             * The policy determines whether vertical scrolling should start
             * below the minimum height or below the natural height.
             * @param policy the vertical `GtkScrollablePolicy`
             */
            set_vscroll_policy(policy: ScrollablePolicy | null): void;
            /**
             * Returns the size of a non-scrolling border around the
             * outside of the scrollable.
             *
             * An example for this would be treeview headers. GTK can use
             * this information to display overlaid graphics, like the
             * overshoot indication, at the right position.
             */
            vfunc_get_border(): [boolean, Border];
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ColumnViewCell {
            // Constructor properties interface

            interface ConstructorProps extends ListItem.ConstructorProps {
                child: Widget;
                focusable: boolean;
                item: GObject.Object;
                position: number;
                selected: boolean;
            }
        }

        /**
         * `GtkColumnViewCell` is used by [class`Gtk`.ColumnViewColumn] to represent items
         * in a cell in [class`Gtk`.ColumnView].
         *
         * The `GtkColumnViewCell`s are managed by the columnview widget (with its factory)
         * and cannot be created by applications, but they need to be populated
         * by application code. This is done by calling [method`Gtk`.ColumnViewCell.set_child].
         *
         * `GtkColumnViewCell`s exist in 2 stages:
         *
         * 1. The unbound stage where the listitem is not currently connected to
         *    an item in the list. In that case, the [property`Gtk`.ColumnViewCell:item]
         *    property is set to %NULL.
         *
         * 2. The bound stage where the listitem references an item from the list.
         *    The [property`Gtk`.ColumnViewCell:item] property is not %NULL.
         */
        class ColumnViewCell extends ListItem {
            static $gtype: GObject.GType<ColumnViewCell>;

            // Properties

            /**
             * Widget used for display.
             */
            get child(): Widget;
            set child(val: Widget);
            /**
             * If the item can be focused with the keyboard.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * Displayed item.
             */
            get item(): GObject.Object;
            /**
             * Position of the item.
             */
            get position(): number;
            /**
             * If the item is currently selected.
             */
            get selected(): boolean;

            // Constructors

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

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

            // Methods

            /**
             * Gets the child previously set via gtk_column_view_cell_set_child() or
             * %NULL if none was set.
             * @returns The child
             */
            get_child(): Widget | null;
            /**
             * Checks if a list item has been set to be focusable via
             * gtk_column_view_cell_set_focusable().
             * @returns %TRUE if the item is focusable
             */
            get_focusable(): boolean;
            /**
             * Gets the model item that associated with `self`.
             *
             * If `self` is unbound, this function returns %NULL.
             * @returns The item displayed
             */
            get_item<T = GObject.Object>(): T;
            /**
             * Gets the position in the model that `self` currently displays.
             *
             * If `self` is unbound, %GTK_INVALID_LIST_POSITION is returned.
             * @returns The position of this item
             */
            get_position(): number;
            /**
             * Checks if the item is displayed as selected.
             *
             * The selected state is maintained by the list widget and its model
             * and cannot be set otherwise.
             * @returns %TRUE if the item is selected.
             */
            get_selected(): boolean;
            /**
             * Sets the child to be used for this listitem.
             *
             * This function is typically called by applications when
             * setting up a listitem so that the widget can be reused when
             * binding it multiple times.
             * @param child The list item's child or %NULL to unset
             */
            set_child(child?: Widget | null): void;
            /**
             * Sets `self` to be focusable.
             *
             * If an item is focusable, it can be focused using the keyboard.
             * This works similar to [method`Gtk`.Widget.set_focusable].
             *
             * Note that if items are not focusable, the keyboard cannot be used to activate
             * them and selecting only works if one of the listitem's children is focusable.
             *
             * By default, list items are focusable.
             * @param focusable if the item should be focusable
             */
            set_focusable(focusable: boolean): void;
        }

        namespace ColumnViewColumn {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                column_view: ColumnView;
                columnView: ColumnView;
                expand: boolean;
                factory: ListItemFactory;
                fixed_width: number;
                fixedWidth: number;
                header_menu: Gio.MenuModel;
                headerMenu: Gio.MenuModel;
                id: string;
                resizable: boolean;
                sorter: Sorter;
                title: string;
                visible: boolean;
            }
        }

        /**
         * `GtkColumnViewColumn` represents the columns being added to a `GtkColumnView`.
         *
         * The main ingredient for a `GtkColumnViewColumn` is the `GtkListItemFactory`
         * that tells the columnview how to create cells for this column from items in
         * the model.
         *
         * Columns have a title, and can optionally have a header menu set
         * with [method`Gtk`.ColumnViewColumn.set_header_menu].
         *
         * A sorter can be associated with a column using
         * [method`Gtk`.ColumnViewColumn.set_sorter], to let users influence sorting
         * by clicking on the column header.
         */
        class ColumnViewColumn extends GObject.Object {
            static $gtype: GObject.GType<ColumnViewColumn>;

            // Properties

            /**
             * The `GtkColumnView` this column is a part of.
             */
            get column_view(): ColumnView;
            /**
             * The `GtkColumnView` this column is a part of.
             */
            get columnView(): ColumnView;
            /**
             * Column gets share of extra width allocated to the view.
             */
            get expand(): boolean;
            set expand(val: boolean);
            /**
             * Factory for populating list items.
             *
             * The factory must be for configuring [class`Gtk`.ColumnViewCell] objects.
             */
            get factory(): ListItemFactory;
            set factory(val: ListItemFactory);
            /**
             * If not -1, this is the width that the column is allocated,
             * regardless of the size of its content.
             */
            get fixed_width(): number;
            set fixed_width(val: number);
            /**
             * If not -1, this is the width that the column is allocated,
             * regardless of the size of its content.
             */
            get fixedWidth(): number;
            set fixedWidth(val: number);
            /**
             * Menu model used to create the context menu for the column header.
             */
            get header_menu(): Gio.MenuModel;
            set header_menu(val: Gio.MenuModel);
            /**
             * Menu model used to create the context menu for the column header.
             */
            get headerMenu(): Gio.MenuModel;
            set headerMenu(val: Gio.MenuModel);
            /**
             * An ID for the column.
             *
             * GTK is not currently using the ID for anything, but
             * it can be used by applications when saving column view
             * configurations.
             *
             * It is up to applications to ensure uniqueness of IDs.
             */
            get id(): string;
            set id(val: string);
            /**
             * Whether this column is resizable.
             */
            get resizable(): boolean;
            set resizable(val: boolean);
            /**
             * Sorter for sorting items according to this column.
             */
            get sorter(): Sorter;
            set sorter(val: Sorter);
            /**
             * Title displayed in the header.
             */
            get title(): string;
            set title(val: string);
            /**
             * Whether this column is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);

            // Constructors

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

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

            static ['new'](title?: string | null, factory?: ListItemFactory | null): ColumnViewColumn;

            // Methods

            /**
             * Gets the column view that's currently displaying this column.
             *
             * If `self` has not been added to a column view yet, %NULL is returned.
             * @returns The column view displaying @self.
             */
            get_column_view(): ColumnView | null;
            /**
             * Returns whether this column should expand.
             * @returns %TRUE if this column expands
             */
            get_expand(): boolean;
            /**
             * Gets the factory that's currently used to populate list items for
             * this column.
             * @returns The factory in use
             */
            get_factory(): ListItemFactory | null;
            /**
             * Gets the fixed width of the column.
             * @returns the fixed with of the column
             */
            get_fixed_width(): number;
            /**
             * Gets the menu model that is used to create the context menu
             * for the column header.
             * @returns the `GMenuModel`
             */
            get_header_menu(): Gio.MenuModel | null;
            /**
             * Returns the ID set with gtk_column_view_column_set_id().
             * @returns The column's ID
             */
            get_id(): string | null;
            /**
             * Returns whether this column is resizable.
             * @returns %TRUE if this column is resizable
             */
            get_resizable(): boolean;
            /**
             * Returns the sorter that is associated with the column.
             * @returns the `GtkSorter` of @self
             */
            get_sorter(): Sorter | null;
            /**
             * Returns the title set with gtk_column_view_column_set_title().
             * @returns The column's title
             */
            get_title(): string | null;
            /**
             * Returns whether this column is visible.
             * @returns %TRUE if this column is visible
             */
            get_visible(): boolean;
            /**
             * Sets the column to take available extra space.
             *
             * The extra space is shared equally amongst all columns that
             * have the expand set to %TRUE.
             * @param expand %TRUE if this column should expand to fill available sace
             */
            set_expand(expand: boolean): void;
            /**
             * Sets the `GtkListItemFactory` to use for populating list items for this
             * column.
             * @param factory the factory to use
             */
            set_factory(factory?: ListItemFactory | null): void;
            /**
             * If `fixed_width` is not -1, sets the fixed width of `column;`
             * otherwise unsets it.
             *
             * Setting a fixed width overrides the automatically calculated
             * width. Interactive resizing also sets the “fixed-width” property.
             * @param fixed_width the new fixed width, or -1
             */
            set_fixed_width(fixed_width: number): void;
            /**
             * Sets the menu model that is used to create the context menu
             * for the column header.
             * @param menu a `GMenuModel`
             */
            set_header_menu(menu?: Gio.MenuModel | null): void;
            /**
             * Sets the id of this column.
             *
             * GTK makes no use of this, but applications can use it when
             * storing column view configuration.
             *
             * It is up to callers to ensure uniqueness of IDs.
             * @param id ID to use for this column
             */
            set_id(id?: string | null): void;
            /**
             * Sets whether this column should be resizable by dragging.
             * @param resizable whether this column should be resizable
             */
            set_resizable(resizable: boolean): void;
            /**
             * Associates a sorter with the column.
             *
             * If `sorter` is %NULL, the column will not let users change
             * the sorting by clicking on its header.
             *
             * This sorter can be made active by clicking on the column
             * header, or by calling [method`Gtk`.ColumnView.sort_by_column].
             *
             * See [method`Gtk`.ColumnView.get_sorter] for the necessary steps
             * for setting up customizable sorting for [class`Gtk`.ColumnView].
             * @param sorter the `GtkSorter` to associate with @column
             */
            set_sorter(sorter?: Sorter | null): void;
            /**
             * Sets the title of this column.
             *
             * The title is displayed in the header of a `GtkColumnView`
             * for this column and is therefore user-facing text that should
             * be translated.
             * @param title Title to use for this column
             */
            set_title(title?: string | null): void;
            /**
             * Sets whether this column should be visible in views.
             * @param visible whether this column should be visible
             */
            set_visible(visible: boolean): void;
        }

        namespace ColumnViewRow {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                accessible_description: string;
                accessibleDescription: string;
                accessible_label: string;
                accessibleLabel: string;
                activatable: boolean;
                focusable: boolean;
                item: GObject.Object;
                position: number;
                selectable: boolean;
                selected: boolean;
            }
        }

        /**
         * `GtkColumnViewRow` is used by [class`Gtk`.ColumnView] to allow configuring
         * how rows are displayed.
         *
         * It is not used to set the widgets displayed in the individual cells. For that
         * see [method`GtkColumnViewColumn`.set_factory] and [class`GtkColumnViewCell]`.
         */
        class ColumnViewRow extends GObject.Object {
            static $gtype: GObject.GType<ColumnViewRow>;

            // Properties

            /**
             * The accessible description to set on the row.
             */
            get accessible_description(): string;
            set accessible_description(val: string);
            /**
             * The accessible description to set on the row.
             */
            get accessibleDescription(): string;
            set accessibleDescription(val: string);
            /**
             * The accessible label to set on the row.
             */
            get accessible_label(): string;
            set accessible_label(val: string);
            /**
             * The accessible label to set on the row.
             */
            get accessibleLabel(): string;
            set accessibleLabel(val: string);
            /**
             * If the row can be activated by the user.
             */
            get activatable(): boolean;
            set activatable(val: boolean);
            /**
             * If the row can be focused with the keyboard.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * The item for this row.
             */
            get item(): GObject.Object;
            /**
             * Position of the row.
             */
            get position(): number;
            /**
             * If the row can be selected by the user.
             */
            get selectable(): boolean;
            set selectable(val: boolean);
            /**
             * If the item in the row is currently selected.
             */
            get selected(): boolean;

            // Constructors

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

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

            // Methods

            /**
             * Gets the accessible description of `self`.
             * @returns the accessible description
             */
            get_accessible_description(): string;
            /**
             * Gets the accessible label of `self`.
             * @returns the accessible label
             */
            get_accessible_label(): string;
            /**
             * Checks if the row has been set to be activatable via
             * gtk_column_view_row_set_activatable().
             * @returns %TRUE if the row is activatable
             */
            get_activatable(): boolean;
            /**
             * Checks if a row item has been set to be focusable via
             * gtk_column_view_row_set_focusable().
             * @returns %TRUE if the row is focusable
             */
            get_focusable(): boolean;
            /**
             * Gets the model item that associated with `self`.
             *
             * If `self` is unbound, this function returns %NULL.
             * @returns The item displayed
             */
            get_item<T = GObject.Object>(): T;
            /**
             * Gets the position in the model that `self` currently displays.
             *
             * If `self` is unbound, %GTK_INVALID_LIST_POSITION is returned.
             * @returns The position of this row
             */
            get_position(): number;
            /**
             * Checks if the row has been set to be selectable via
             * gtk_column_view_row_set_selectable().
             *
             * Do not confuse this function with [method`Gtk`.ColumnViewRow.get_selected].
             * @returns %TRUE if the row is selectable
             */
            get_selectable(): boolean;
            /**
             * Checks if the item is selected that this row corresponds to.
             *
             * The selected state is maintained by the list widget and its model
             * and cannot be set otherwise.
             * @returns %TRUE if the item is selected.
             */
            get_selected(): boolean;
            /**
             * Sets the accessible description for the row,
             * which may be used by e.g. screen readers.
             * @param description the description
             */
            set_accessible_description(description: string): void;
            /**
             * Sets the accessible label for the row,
             * which may be used by e.g. screen readers.
             * @param label the label
             */
            set_accessible_label(label: string): void;
            /**
             * Sets `self` to be activatable.
             *
             * If a row is activatable, double-clicking on the row, using
             * the Return key or calling gtk_widget_activate() will activate
             * the row. Activating instructs the containing columnview to
             * emit the [signal`Gtk`.ColumnView::activate] signal.
             *
             * By default, row are activatable.
             * @param activatable if the row should be activatable
             */
            set_activatable(activatable: boolean): void;
            /**
             * Sets `self` to be focusable.
             *
             * If a row is focusable, it can be focused using the keyboard.
             * This works similar to [method`Gtk`.Widget.set_focusable].
             *
             * Note that if row are not focusable, the contents of cells can still be focused if
             * they are focusable.
             *
             * By default, rows are focusable.
             * @param focusable if the row should be focusable
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets `self` to be selectable.
             *
             * If a row is selectable, clicking on the row or using the keyboard
             * will try to select or unselect the row. Whether this succeeds is up to
             * the model to determine, as it is managing the selected state.
             *
             * Note that this means that making a row non-selectable has no
             * influence on the selected state at all. A non-selectable row
             * may still be selected.
             *
             * By default, rows are selectable.
             * @param selectable if the row should be selectable
             */
            set_selectable(selectable: boolean): void;
        }

        namespace ColumnViewSorter {
            // Constructor properties interface

            interface ConstructorProps extends Sorter.ConstructorProps {
                primary_sort_column: ColumnViewColumn;
                primarySortColumn: ColumnViewColumn;
                primary_sort_order: SortType;
                primarySortOrder: SortType;
            }
        }

        /**
         * `GtkColumnViewSorter` is a sorter implementation that
         * is geared towards the needs of `GtkColumnView`.
         *
         * The sorter returned by [method`Gtk`.ColumnView.get_sorter] is
         * a `GtkColumnViewSorter`.
         *
         * In column views, sorting can be configured by associating
         * sorters with columns, and users can invert sort order by clicking
         * on column headers. The API of `GtkColumnViewSorter` is designed
         * to allow saving and restoring this configuration.
         *
         * If you are only interested in the primary sort column (i.e. the
         * column where a sort indicator is shown in the header), then
         * you can just look at [property`Gtk`.ColumnViewSorter:primary-sort-column]
         * and [property`Gtk`.ColumnViewSorter:primary-sort-order].
         *
         * If you want to store the full sort configuration, including
         * secondary sort columns that are used for tie breaking, then
         * you can use [method`Gtk`.ColumnViewSorter.get_nth_sort_column].
         * To get notified about changes, use [signal`Gtk`.Sorter::changed].
         *
         * To restore a saved sort configuration on a `GtkColumnView`,
         * use code like:
         *
         * ```
         * sorter = gtk_column_view_get_sorter (view);
         * for (i = gtk_column_view_sorter_get_n_sort_columns (sorter) - 1; i >= 0; i--)
         *   {
         *     column = gtk_column_view_sorter_get_nth_sort_column (sorter, i, &order);
         *     gtk_column_view_sort_by_column (view, column, order);
         *   }
         * ```
         */
        class ColumnViewSorter extends Sorter {
            static $gtype: GObject.GType<ColumnViewSorter>;

            // Properties

            /**
             * The primary sort column.
             *
             * The primary sort column is the one that displays the triangle
             * in a column view header.
             */
            get primary_sort_column(): ColumnViewColumn;
            /**
             * The primary sort column.
             *
             * The primary sort column is the one that displays the triangle
             * in a column view header.
             */
            get primarySortColumn(): ColumnViewColumn;
            /**
             * The primary sort order.
             *
             * The primary sort order determines whether the triangle displayed
             * in the column view header of the primary sort column points upwards
             * or downwards.
             */
            get primary_sort_order(): SortType;
            /**
             * The primary sort order.
             *
             * The primary sort order determines whether the triangle displayed
             * in the column view header of the primary sort column points upwards
             * or downwards.
             */
            get primarySortOrder(): SortType;

            // Constructors

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

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

            // Methods

            /**
             * Returns the number of columns by which the sorter sorts.
             *
             * If the sorter of the primary sort column does not determine
             * a total order, then the secondary sorters are consulted to
             * break the ties.
             *
             * Use the [signal`Gtk`.Sorter::changed] signal to get notified
             * when the number of sort columns changes.
             * @returns the number of sort columns
             */
            get_n_sort_columns(): number;
            /**
             * Gets the `position'`th sort column and its associated sort order.
             *
             * Use the [signal`Gtk`.Sorter::changed] signal to get notified
             * when sort columns change.
             * @param position the position of the sort column to retrieve (0 for the     primary sort column)
             * @returns the @positions sort column
             */
            get_nth_sort_column(position: number): [ColumnViewColumn | null, SortType];
            /**
             * Returns the primary sort column.
             *
             * The primary sort column is the one that displays the triangle
             * in a column view header.
             * @returns the primary sort column
             */
            get_primary_sort_column(): ColumnViewColumn | null;
            /**
             * Returns the primary sort order.
             *
             * The primary sort order determines whether the triangle displayed
             * in the column view header of the primary sort column points upwards
             * or downwards.
             *
             * If there is no primary sort column, then this function returns
             * `GTK_SORT_ASCENDING`.
             * @returns the primary sort order
             */
            get_primary_sort_order(): SortType;
        }

        namespace ComboBox {
            // Signal callback interfaces

            interface Activate {
                (): void;
            }

            interface Changed {
                (): void;
            }

            interface FormatEntryText {
                (path: string): string;
            }

            interface MoveActive {
                (scroll_type: ScrollType): void;
            }

            interface Popdown {
                (): boolean;
            }

            interface Popup {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    CellEditable.ConstructorProps,
                    CellLayout.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                active: number;
                active_id: string;
                activeId: string;
                button_sensitivity: SensitivityType;
                buttonSensitivity: SensitivityType;
                child: Widget;
                entry_text_column: number;
                entryTextColumn: number;
                has_entry: boolean;
                hasEntry: boolean;
                has_frame: boolean;
                hasFrame: boolean;
                id_column: number;
                idColumn: number;
                model: TreeModel;
                popup_fixed_width: boolean;
                popupFixedWidth: boolean;
                popup_shown: boolean;
                popupShown: boolean;
            }
        }

        /**
         * A `GtkComboBox` is a widget that allows the user to choose from a list of
         * valid choices.
         *
         * ![An example GtkComboBox](combo-box.png)
         *
         * The `GtkComboBox` displays the selected choice; when activated, the
         * `GtkComboBox` displays a popup which allows the user to make a new choice.
         *
         * The `GtkComboBox` uses the model-view pattern; the list of valid choices
         * is specified in the form of a tree model, and the display of the choices
         * can be adapted to the data in the model by using cell renderers, as you
         * would in a tree view. This is possible since `GtkComboBox` implements the
         * [iface`Gtk`.CellLayout] interface. The tree model holding the valid
         * choices is not restricted to a flat list, it can be a real tree, and the
         * popup will reflect the tree structure.
         *
         * To allow the user to enter values not in the model, the
         * [property`Gtk`.ComboBox:has-entry] property allows the `GtkComboBox` to
         * contain a [class`Gtk`.Entry]. This entry can be accessed by calling
         * [method`Gtk`.ComboBox.get_child] on the combo box.
         *
         * For a simple list of textual choices, the model-view API of `GtkComboBox`
         * can be a bit overwhelming. In this case, [class`Gtk`.ComboBoxText] offers
         * a simple alternative. Both `GtkComboBox` and `GtkComboBoxText` can contain
         * an entry.
         *
         * ## CSS nodes
         *
         * ```
         * combobox
         * ├── box.linked
         * │   ╰── button.combo
         * │       ╰── box
         * │           ├── cellview
         * │           ╰── arrow
         * ╰── window.popup
         * ```
         *
         * A normal combobox contains a box with the .linked class, a button
         * with the .combo class and inside those buttons, there are a cellview and
         * an arrow.
         *
         * ```
         * combobox
         * ├── box.linked
         * │   ├── entry.combo
         * │   ╰── button.combo
         * │       ╰── box
         * │           ╰── arrow
         * ╰── window.popup
         * ```
         *
         * A `GtkComboBox` with an entry has a single CSS node with name combobox.
         * It contains a box with the .linked class. That box contains an entry and
         * a button, both with the .combo class added. The button also contains another
         * node with name arrow.
         *
         * ## Accessibility
         *
         * `GtkComboBox` uses the %GTK_ACCESSIBLE_ROLE_COMBO_BOX role.
         */
        class ComboBox extends Widget implements Accessible, Buildable, CellEditable, CellLayout, ConstraintTarget {
            static $gtype: GObject.GType<ComboBox>;

            // Properties

            /**
             * The item which is currently active.
             *
             * If the model is a non-flat treemodel, and the active item is not an
             * immediate child of the root of the tree, this property has the value
             * `gtk_tree_path_get_indices (path)[0]`, where `path` is the
             * [struct`Gtk`.TreePath] of the active item.
             */
            get active(): number;
            set active(val: number);
            /**
             * The value of the ID column of the active row.
             */
            get active_id(): string;
            set active_id(val: string);
            /**
             * The value of the ID column of the active row.
             */
            get activeId(): string;
            set activeId(val: string);
            /**
             * Whether the dropdown button is sensitive when
             * the model is empty.
             */
            get button_sensitivity(): SensitivityType;
            set button_sensitivity(val: SensitivityType);
            /**
             * Whether the dropdown button is sensitive when
             * the model is empty.
             */
            get buttonSensitivity(): SensitivityType;
            set buttonSensitivity(val: SensitivityType);
            /**
             * The child widget.
             */
            get child(): Widget;
            set child(val: Widget);
            /**
             * The model column to associate with strings from the entry.
             *
             * This is property only relevant if the combo was created with
             * [property`Gtk`.ComboBox:has-entry] is %TRUE.
             */
            get entry_text_column(): number;
            set entry_text_column(val: number);
            /**
             * The model column to associate with strings from the entry.
             *
             * This is property only relevant if the combo was created with
             * [property`Gtk`.ComboBox:has-entry] is %TRUE.
             */
            get entryTextColumn(): number;
            set entryTextColumn(val: number);
            /**
             * Whether the combo box has an entry.
             */
            get has_entry(): boolean;
            /**
             * Whether the combo box has an entry.
             */
            get hasEntry(): boolean;
            /**
             * The `has-frame` property controls whether a frame is drawn around the entry.
             */
            get has_frame(): boolean;
            set has_frame(val: boolean);
            /**
             * The `has-frame` property controls whether a frame is drawn around the entry.
             */
            get hasFrame(): boolean;
            set hasFrame(val: boolean);
            /**
             * The model column that provides string IDs for the values
             * in the model, if != -1.
             */
            get id_column(): number;
            set id_column(val: number);
            /**
             * The model column that provides string IDs for the values
             * in the model, if != -1.
             */
            get idColumn(): number;
            set idColumn(val: number);
            /**
             * The model from which the combo box takes its values.
             */
            get model(): TreeModel;
            set model(val: TreeModel);
            /**
             * Whether the popup's width should be a fixed width matching the
             * allocated width of the combo box.
             */
            get popup_fixed_width(): boolean;
            set popup_fixed_width(val: boolean);
            /**
             * Whether the popup's width should be a fixed width matching the
             * allocated width of the combo box.
             */
            get popupFixedWidth(): boolean;
            set popupFixedWidth(val: boolean);
            /**
             * Whether the combo boxes dropdown is popped up.
             *
             * Note that this property is mainly useful, because
             * it allows you to connect to notify::popup-shown.
             */
            get popup_shown(): boolean;
            /**
             * Whether the combo boxes dropdown is popped up.
             *
             * Note that this property is mainly useful, because
             * it allows you to connect to notify::popup-shown.
             */
            get popupShown(): boolean;

            // Constructors

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

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

            static ['new'](): ComboBox;

            static new_with_entry(): ComboBox;

            static new_with_model(model: TreeModel): ComboBox;

            static new_with_model_and_entry(model: TreeModel): ComboBox;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate', callback: (_source: this) => void): number;
            connect_after(signal: 'activate', callback: (_source: this) => void): number;
            emit(signal: 'activate'): void;
            connect(signal: 'changed', callback: (_source: this) => void): number;
            connect_after(signal: 'changed', callback: (_source: this) => void): number;
            emit(signal: 'changed'): void;
            connect(signal: 'format-entry-text', callback: (_source: this, path: string) => string): number;
            connect_after(signal: 'format-entry-text', callback: (_source: this, path: string) => string): number;
            emit(signal: 'format-entry-text', path: string): void;
            connect(signal: 'move-active', callback: (_source: this, scroll_type: ScrollType) => void): number;
            connect_after(signal: 'move-active', callback: (_source: this, scroll_type: ScrollType) => void): number;
            emit(signal: 'move-active', scroll_type: ScrollType): void;
            connect(signal: 'popdown', callback: (_source: this) => boolean): number;
            connect_after(signal: 'popdown', callback: (_source: this) => boolean): number;
            emit(signal: 'popdown'): void;
            connect(signal: 'popup', callback: (_source: this) => void): number;
            connect_after(signal: 'popup', callback: (_source: this) => void): number;
            emit(signal: 'popup'): void;

            // Virtual methods

            vfunc_activate(): void;
            /**
             * Signal is emitted when the active item is changed.
             */
            vfunc_changed(): void;
            /**
             * Signal which allows you to change how the text
             *    displayed in a combo box’s entry is displayed.
             * @param path
             */
            vfunc_format_entry_text(path: string): string;

            // Methods

            /**
             * Returns the index of the currently active item.
             *
             * If the model is a non-flat treemodel, and the active item is not
             * an immediate child of the root of the tree, this function returns
             * `gtk_tree_path_get_indices (path)[0]`, where `path` is the
             * [struct`Gtk`.TreePath] of the active item.
             * @returns An integer which is the index of the currently active item,   or -1 if there’s no active item
             */
            get_active(): number;
            /**
             * Returns the ID of the active row of `combo_box`.
             *
             * This value is taken from the active row and the column specified
             * by the [property`Gtk`.ComboBox:id-column] property of `combo_box`
             * (see [method`Gtk`.ComboBox.set_id_column]).
             *
             * The returned value is an interned string which means that you can
             * compare the pointer by value to other interned strings and that you
             * must not free it.
             *
             * If the [property`Gtk`.ComboBox:id-column] property of `combo_box` is
             * not set, or if no row is active, or if the active row has a %NULL
             * ID value, then %NULL is returned.
             * @returns the ID of the active row
             */
            get_active_id(): string | null;
            /**
             * Sets `iter` to point to the currently active item.
             *
             * If no item is active, `iter` is left unchanged.
             * @returns %TRUE if @iter was set, %FALSE otherwise
             */
            get_active_iter(): [boolean, TreeIter];
            /**
             * Returns whether the combo box sets the dropdown button
             * sensitive or not when there are no items in the model.
             * @returns %GTK_SENSITIVITY_ON if the dropdown button   is sensitive when the model is empty, %GTK_SENSITIVITY_OFF   if the button is always insensitive or %GTK_SENSITIVITY_AUTO   if it is only sensitive as long as the model has one item to   be selected.
             */
            get_button_sensitivity(): SensitivityType;
            /**
             * Gets the child widget of `combo_box`.
             * @returns the child widget of @combo_box
             */
            get_child(): Widget | null;
            /**
             * Returns the column which `combo_box` is using to get the strings
             * from to display in the internal entry.
             * @returns A column in the data source model of @combo_box.
             */
            get_entry_text_column(): number;
            /**
             * Returns whether the combo box has an entry.
             * @returns whether there is an entry in @combo_box.
             */
            get_has_entry(): boolean;
            /**
             * Returns the column which `combo_box` is using to get string IDs
             * for values from.
             * @returns A column in the data source model of @combo_box.
             */
            get_id_column(): number;
            /**
             * Returns the `GtkTreeModel` of `combo_box`.
             * @returns A `GtkTreeModel` which was passed   during construction.
             */
            get_model(): TreeModel | null;
            /**
             * Gets whether the popup uses a fixed width.
             * @returns %TRUE if the popup uses a fixed width
             */
            get_popup_fixed_width(): boolean;
            /**
             * Hides the menu or dropdown list of `combo_box`.
             *
             * This function is mostly intended for use by accessibility technologies;
             * applications should have little use for it.
             */
            popdown(): void;
            /**
             * Pops up the menu or dropdown list of `combo_box`.
             *
             * This function is mostly intended for use by accessibility technologies;
             * applications should have little use for it.
             *
             * Before calling this, `combo_box` must be mapped, or nothing will happen.
             */
            popup(): void;
            /**
             * Pops up the menu of `combo_box`.
             *
             * Note that currently this does not do anything with the device, as it was
             * previously only used for list-mode combo boxes, and those were removed
             * in GTK 4. However, it is retained in case similar functionality is added
             * back later.
             * @param device a `GdkDevice`
             */
            popup_for_device(device: Gdk.Device): void;
            /**
             * Sets the active item of `combo_box` to be the item at `index`.
             * @param index_ An index in the model passed during construction,   or -1 to have no active item
             */
            set_active(index_: number): void;
            /**
             * Changes the active row of `combo_box` to the one that has an ID equal to
             * `active_id`.
             *
             * If `active_id` is %NULL, the active row is unset. Rows having
             * a %NULL ID string cannot be made active by this function.
             *
             * If the [property`Gtk`.ComboBox:id-column] property of `combo_box` is
             * unset or if no row has the given ID then the function does nothing
             * and returns %FALSE.
             * @param active_id the ID of the row to select
             * @returns %TRUE if a row with a matching ID was found. If a %NULL   @active_id was given to unset the active row, the function   always returns %TRUE.
             */
            set_active_id(active_id?: string | null): boolean;
            /**
             * Sets the current active item to be the one referenced by `iter`.
             *
             * If `iter` is %NULL, the active item is unset.
             * @param iter The `GtkTreeIter`
             */
            set_active_iter(iter?: TreeIter | null): void;
            /**
             * Sets whether the dropdown button of the combo box should update
             * its sensitivity depending on the model contents.
             * @param sensitivity specify the sensitivity of the dropdown button
             */
            set_button_sensitivity(sensitivity: SensitivityType | null): void;
            /**
             * Sets the child widget of `combo_box`.
             * @param child the child widget
             */
            set_child(child?: Widget | null): void;
            /**
             * Sets the model column which `combo_box` should use to get strings
             * from to be `text_column`.
             *
             * For this column no separate
             * [class`Gtk`.CellRenderer] is needed.
             *
             * The column `text_column` in the model of `combo_box` must be of
             * type %G_TYPE_STRING.
             *
             * This is only relevant if `combo_box` has been created with
             * [property`Gtk`.ComboBox:has-entry] as %TRUE.
             * @param text_column A column in @model to get the strings from for   the internal entry
             */
            set_entry_text_column(text_column: number): void;
            /**
             * Sets the model column which `combo_box` should use to get string IDs
             * for values from.
             *
             * The column `id_column` in the model of `combo_box` must be of type
             * %G_TYPE_STRING.
             * @param id_column A column in @model to get string IDs for values from
             */
            set_id_column(id_column: number): void;
            /**
             * Sets the model used by `combo_box` to be `model`.
             *
             * Will unset a previously set model (if applicable). If model is %NULL,
             * then it will unset the model.
             *
             * Note that this function does not clear the cell renderers, you have to
             * call [method`Gtk`.CellLayout.clear] yourself if you need to set up different
             * cell renderers for the new model.
             * @param model A `GtkTreeModel`
             */
            set_model(model?: TreeModel | null): void;
            /**
             * Specifies whether the popup’s width should be a fixed width.
             *
             * If `fixed` is %TRUE, the popup's width is set to match the
             * allocated width of the combo box.
             * @param fixed whether to use a fixed popup width
             */
            set_popup_fixed_width(fixed: boolean): void;
            /**
             * Sets the row separator function, which is used to determine
             * whether a row should be drawn as a separator.
             *
             * If the row separator function is %NULL, no separators are drawn.
             * This is the default value.
             * @param func a `GtkTreeViewRowSeparatorFunc`
             * @param destroy destroy notifier for @data
             */
            set_row_separator_func(func?: TreeViewRowSeparatorFunc | null, destroy?: GLib.DestroyNotify | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * Indicates whether editing on the cell has been canceled.
             */
            get editing_canceled(): boolean;
            set editing_canceled(val: boolean);
            /**
             * Indicates whether editing on the cell has been canceled.
             */
            get editingCanceled(): boolean;
            set editingCanceled(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Emits the `GtkCellEditable::editing-done` signal.
             */
            editing_done(): void;
            /**
             * Emits the `GtkCellEditable::remove-widget` signal.
             */
            remove_widget(): void;
            /**
             * Begins editing on a `cell_editable`.
             *
             * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
             * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
             *
             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
             * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
             *
             * Note that the `cell_editable` is created on-demand for the current edit; its
             * lifetime is temporary and does not persist across other edits and/or cells.
             * @param event The `GdkEvent` that began the editing process, or   %NULL if editing was initiated programmatically
             */
            start_editing(event?: Gdk.Event | null): void;
            /**
             * Emits the `GtkCellEditable::editing-done` signal.
             */
            vfunc_editing_done(): void;
            /**
             * Emits the `GtkCellEditable::remove-widget` signal.
             */
            vfunc_remove_widget(): void;
            /**
             * Begins editing on a `cell_editable`.
             *
             * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
             * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
             *
             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
             * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
             *
             * Note that the `cell_editable` is created on-demand for the current edit; its
             * lifetime is temporary and does not persist across other edits and/or cells.
             * @param event The `GdkEvent` that began the editing process, or   %NULL if editing was initiated programmatically
             */
            vfunc_start_editing(event?: Gdk.Event | null): void;
            /**
             * Adds an attribute mapping to the list in `cell_layout`.
             *
             * The `column` is the column of the model to get a value from, and the
             * `attribute` is the property on `cell` to be set from that value. So for
             * example if column 2 of the model contains strings, you could have the
             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
             * In this context "attribute" and "property" are used interchangeably.
             * @param cell a `GtkCellRenderer`
             * @param attribute a property on the renderer
             * @param column the column position on the model to get the attribute from
             */
            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
            /**
             * Unsets all the mappings on all renderers on `cell_layout` and
             * removes all renderers from `cell_layout`.
             */
            clear(): void;
            /**
             * Clears all existing attributes previously set with
             * gtk_cell_layout_set_attributes().
             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
             */
            clear_attributes(cell: CellRenderer): void;
            /**
             * Returns the underlying `GtkCellArea` which might be `cell_layout`
             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
             * is used by `cell_layout`.
             * @returns the cell area used by @cell_layout
             */
            get_area(): CellArea | null;
            /**
             * Returns the cell renderers which have been added to `cell_layout`.
             * @returns a list of cell renderers. The list, but not the renderers has   been newly allocated and should be freed with g_list_free()   when no longer needed.
             */
            get_cells(): CellRenderer[];
            /**
             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
             * `cell` is allocated no more space than it needs. Any unused space is
             * divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            pack_end(cell: CellRenderer, expand: boolean): void;
            /**
             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
             * then the `cell` is allocated no more space than it needs. Any unused space
             * is divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            pack_start(cell: CellRenderer, expand: boolean): void;
            /**
             * Re-inserts `cell` at `position`.
             *
             * Note that `cell` has already to be packed into `cell_layout`
             * for this to function properly.
             * @param cell a `GtkCellRenderer` to reorder
             * @param position new position to insert @cell at
             */
            reorder(cell: CellRenderer, position: number): void;
            /**
             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
             *
             * This function is used instead of the standard attributes mapping
             * for setting the column value, and should set the value of `cell_layout’`s
             * cell renderer(s) as appropriate.
             *
             * `func` may be %NULL to remove a previously set function.
             * @param cell a `GtkCellRenderer`
             * @param func the `GtkCellLayout`DataFunc to use
             */
            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
            /**
             * Adds an attribute mapping to the list in `cell_layout`.
             *
             * The `column` is the column of the model to get a value from, and the
             * `attribute` is the property on `cell` to be set from that value. So for
             * example if column 2 of the model contains strings, you could have the
             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
             * In this context "attribute" and "property" are used interchangeably.
             * @param cell a `GtkCellRenderer`
             * @param attribute a property on the renderer
             * @param column the column position on the model to get the attribute from
             */
            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
            /**
             * Unsets all the mappings on all renderers on `cell_layout` and
             * removes all renderers from `cell_layout`.
             */
            vfunc_clear(): void;
            /**
             * Clears all existing attributes previously set with
             * gtk_cell_layout_set_attributes().
             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
             */
            vfunc_clear_attributes(cell: CellRenderer): void;
            /**
             * Returns the underlying `GtkCellArea` which might be `cell_layout`
             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
             * is used by `cell_layout`.
             */
            vfunc_get_area(): CellArea | null;
            /**
             * Returns the cell renderers which have been added to `cell_layout`.
             */
            vfunc_get_cells(): CellRenderer[];
            /**
             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
             * `cell` is allocated no more space than it needs. Any unused space is
             * divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
            /**
             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
             * then the `cell` is allocated no more space than it needs. Any unused space
             * is divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
            /**
             * Re-inserts `cell` at `position`.
             *
             * Note that `cell` has already to be packed into `cell_layout`
             * for this to function properly.
             * @param cell a `GtkCellRenderer` to reorder
             * @param position new position to insert @cell at
             */
            vfunc_reorder(cell: CellRenderer, position: number): void;
            /**
             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
             *
             * This function is used instead of the standard attributes mapping
             * for setting the column value, and should set the value of `cell_layout’`s
             * cell renderer(s) as appropriate.
             *
             * `func` may be %NULL to remove a previously set function.
             * @param cell a `GtkCellRenderer`
             * @param func the `GtkCellLayout`DataFunc to use
             */
            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace ComboBoxText {
            // Constructor properties interface

            interface ConstructorProps
                extends ComboBox.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    CellEditable.ConstructorProps,
                    CellLayout.ConstructorProps,
                    ConstraintTarget.ConstructorProps {}
        }

        /**
         * A `GtkComboBoxText` is a simple variant of `GtkComboBox` for text-only
         * use cases.
         *
         * ![An example GtkComboBoxText](combo-box-text.png)
         *
         * `GtkComboBoxText` hides the model-view complexity of `GtkComboBox`.
         *
         * To create a `GtkComboBoxText`, use [ctor`Gtk`.ComboBoxText.new] or
         * [ctor`Gtk`.ComboBoxText.new_with_entry].
         *
         * You can add items to a `GtkComboBoxText` with
         * [method`Gtk`.ComboBoxText.append_text],
         * [method`Gtk`.ComboBoxText.insert_text] or
         * [method`Gtk`.ComboBoxText.prepend_text] and remove options with
         * [method`Gtk`.ComboBoxText.remove].
         *
         * If the `GtkComboBoxText` contains an entry (via the
         * [property`Gtk`.ComboBox:has-entry] property), its contents can be retrieved
         * using [method`Gtk`.ComboBoxText.get_active_text].
         *
         * You should not call [method`Gtk`.ComboBox.set_model] or attempt to pack more
         * cells into this combo box via its [iface`Gtk`.CellLayout] interface.
         *
         * ## GtkComboBoxText as GtkBuildable
         *
         * The `GtkComboBoxText` implementation of the `GtkBuildable` interface supports
         * adding items directly using the `<items>` element and specifying `<item>`
         * elements for each item. Each `<item>` element can specify the “id”
         * corresponding to the appended text and also supports the regular
         * translation attributes “translatable”, “context” and “comments”.
         *
         * Here is a UI definition fragment specifying `GtkComboBoxText` items:
         * ```xml
         * <object class="GtkComboBoxText">
         *   <items>
         *     <item translatable="yes" id="factory">Factory</item>
         *     <item translatable="yes" id="home">Home</item>
         *     <item translatable="yes" id="subway">Subway</item>
         *   </items>
         * </object>
         * ```
         *
         * ## CSS nodes
         *
         * ```
         * combobox
         * ╰── box.linked
         *     ├── entry.combo
         *     ├── button.combo
         *     ╰── window.popup
         * ```
         *
         * `GtkComboBoxText` has a single CSS node with name combobox. It adds
         * the style class .combo to the main CSS nodes of its entry and button
         * children, and the .linked class to the node of its internal box.
         */
        class ComboBoxText
            extends ComboBox
            implements Accessible, Buildable, CellEditable, CellLayout, ConstraintTarget
        {
            static $gtype: GObject.GType<ComboBoxText>;

            // Constructors

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

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

            static ['new'](): ComboBoxText;

            static new_with_entry(): ComboBoxText;

            // Methods

            /**
             * Appends `text` to the list of strings stored in `combo_box`.
             *
             * If `id` is non-%NULL then it is used as the ID of the row.
             *
             * This is the same as calling [method`Gtk`.ComboBoxText.insert]
             * with a position of -1.
             * @param id a string ID for this value
             * @param text A string
             */
            append(id: string | null, text: string): void;
            /**
             * Appends `text` to the list of strings stored in `combo_box`.
             *
             * This is the same as calling [method`Gtk`.ComboBoxText.insert_text]
             * with a position of -1.
             * @param text A string
             */
            append_text(text: string): void;
            /**
             * Returns the currently active string in `combo_box`.
             *
             * If no row is currently selected, %NULL is returned.
             * If `combo_box` contains an entry, this function will
             * return its contents (which will not necessarily
             * be an item from the list).
             * @returns a newly allocated   string containing the currently active text.   Must be freed with g_free().
             */
            get_active_text(): string | null;
            /**
             * Inserts `text` at `position` in the list of strings stored in `combo_box`.
             *
             * If `id` is non-%NULL then it is used as the ID of the row.
             * See [property`Gtk`.ComboBox:id-column].
             *
             * If `position` is negative then `text` is appended.
             * @param position An index to insert @text
             * @param id a string ID for this value
             * @param text A string to display
             */
            insert(position: number, id: string | null, text: string): void;
            /**
             * Inserts `text` at `position` in the list of strings stored in `combo_box`.
             *
             * If `position` is negative then `text` is appended.
             *
             * This is the same as calling [method`Gtk`.ComboBoxText.insert]
             * with a %NULL ID string.
             * @param position An index to insert @text
             * @param text A string
             */
            insert_text(position: number, text: string): void;
            /**
             * Prepends `text` to the list of strings stored in `combo_box`.
             *
             * If `id` is non-%NULL then it is used as the ID of the row.
             *
             * This is the same as calling [method`Gtk`.ComboBoxText.insert]
             * with a position of 0.
             * @param id a string ID for this value
             * @param text a string
             */
            prepend(id: string | null, text: string): void;
            /**
             * Prepends `text` to the list of strings stored in `combo_box`.
             *
             * This is the same as calling [method`Gtk`.ComboBoxText.insert_text]
             * with a position of 0.
             * @param text A string
             */
            prepend_text(text: string): void;
            /**
             * Removes the string at `position` from `combo_box`.
             * @param position Index of the item to remove
             */
            remove(position: number): void;
            /**
             * Removes all the text entries from the combo box.
             */
            remove_all(): void;

            // Inherited properties
            /**
             * Indicates whether editing on the cell has been canceled.
             */
            get editing_canceled(): boolean;
            set editing_canceled(val: boolean);
            /**
             * Indicates whether editing on the cell has been canceled.
             */
            get editingCanceled(): boolean;
            set editingCanceled(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Emits the `GtkCellEditable::editing-done` signal.
             */
            editing_done(): void;
            /**
             * Emits the `GtkCellEditable::remove-widget` signal.
             */
            remove_widget(): void;
            /**
             * Begins editing on a `cell_editable`.
             *
             * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
             * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
             *
             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
             * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
             *
             * Note that the `cell_editable` is created on-demand for the current edit; its
             * lifetime is temporary and does not persist across other edits and/or cells.
             * @param event The `GdkEvent` that began the editing process, or   %NULL if editing was initiated programmatically
             */
            start_editing(event?: Gdk.Event | null): void;
            /**
             * Emits the `GtkCellEditable::editing-done` signal.
             */
            vfunc_editing_done(): void;
            /**
             * Emits the `GtkCellEditable::remove-widget` signal.
             */
            vfunc_remove_widget(): void;
            /**
             * Begins editing on a `cell_editable`.
             *
             * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
             * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
             *
             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
             * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
             *
             * Note that the `cell_editable` is created on-demand for the current edit; its
             * lifetime is temporary and does not persist across other edits and/or cells.
             * @param event The `GdkEvent` that began the editing process, or   %NULL if editing was initiated programmatically
             */
            vfunc_start_editing(event?: Gdk.Event | null): void;
            /**
             * Adds an attribute mapping to the list in `cell_layout`.
             *
             * The `column` is the column of the model to get a value from, and the
             * `attribute` is the property on `cell` to be set from that value. So for
             * example if column 2 of the model contains strings, you could have the
             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
             * In this context "attribute" and "property" are used interchangeably.
             * @param cell a `GtkCellRenderer`
             * @param attribute a property on the renderer
             * @param column the column position on the model to get the attribute from
             */
            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
            /**
             * Unsets all the mappings on all renderers on `cell_layout` and
             * removes all renderers from `cell_layout`.
             */
            clear(): void;
            /**
             * Clears all existing attributes previously set with
             * gtk_cell_layout_set_attributes().
             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
             */
            clear_attributes(cell: CellRenderer): void;
            /**
             * Returns the underlying `GtkCellArea` which might be `cell_layout`
             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
             * is used by `cell_layout`.
             * @returns the cell area used by @cell_layout
             */
            get_area(): CellArea | null;
            /**
             * Returns the cell renderers which have been added to `cell_layout`.
             * @returns a list of cell renderers. The list, but not the renderers has   been newly allocated and should be freed with g_list_free()   when no longer needed.
             */
            get_cells(): CellRenderer[];
            /**
             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
             * `cell` is allocated no more space than it needs. Any unused space is
             * divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            pack_end(cell: CellRenderer, expand: boolean): void;
            /**
             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
             * then the `cell` is allocated no more space than it needs. Any unused space
             * is divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            pack_start(cell: CellRenderer, expand: boolean): void;
            /**
             * Re-inserts `cell` at `position`.
             *
             * Note that `cell` has already to be packed into `cell_layout`
             * for this to function properly.
             * @param cell a `GtkCellRenderer` to reorder
             * @param position new position to insert @cell at
             */
            reorder(cell: CellRenderer, position: number): void;
            /**
             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
             *
             * This function is used instead of the standard attributes mapping
             * for setting the column value, and should set the value of `cell_layout’`s
             * cell renderer(s) as appropriate.
             *
             * `func` may be %NULL to remove a previously set function.
             * @param cell a `GtkCellRenderer`
             * @param func the `GtkCellLayout`DataFunc to use
             */
            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
            /**
             * Adds an attribute mapping to the list in `cell_layout`.
             *
             * The `column` is the column of the model to get a value from, and the
             * `attribute` is the property on `cell` to be set from that value. So for
             * example if column 2 of the model contains strings, you could have the
             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
             * In this context "attribute" and "property" are used interchangeably.
             * @param cell a `GtkCellRenderer`
             * @param attribute a property on the renderer
             * @param column the column position on the model to get the attribute from
             */
            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
            /**
             * Unsets all the mappings on all renderers on `cell_layout` and
             * removes all renderers from `cell_layout`.
             */
            vfunc_clear(): void;
            /**
             * Clears all existing attributes previously set with
             * gtk_cell_layout_set_attributes().
             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
             */
            vfunc_clear_attributes(cell: CellRenderer): void;
            /**
             * Returns the underlying `GtkCellArea` which might be `cell_layout`
             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
             * is used by `cell_layout`.
             */
            vfunc_get_area(): CellArea | null;
            /**
             * Returns the cell renderers which have been added to `cell_layout`.
             */
            vfunc_get_cells(): CellRenderer[];
            /**
             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
             * `cell` is allocated no more space than it needs. Any unused space is
             * divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
            /**
             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
             * then the `cell` is allocated no more space than it needs. Any unused space
             * is divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
            /**
             * Re-inserts `cell` at `position`.
             *
             * Note that `cell` has already to be packed into `cell_layout`
             * for this to function properly.
             * @param cell a `GtkCellRenderer` to reorder
             * @param position new position to insert @cell at
             */
            vfunc_reorder(cell: CellRenderer, position: number): void;
            /**
             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
             *
             * This function is used instead of the standard attributes mapping
             * for setting the column value, and should set the value of `cell_layout’`s
             * cell renderer(s) as appropriate.
             *
             * `func` may be %NULL to remove a previously set function.
             * @param cell a `GtkCellRenderer`
             * @param func the `GtkCellLayout`DataFunc to use
             */
            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        /**
         * A constant value in a `GtkExpression`.
         */
        class ConstantExpression extends Expression {
            static $gtype: GObject.GType<ConstantExpression>;

            // Constructors

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

            static new_for_value(value: GObject.Value | any): ConstantExpression;

            // Methods

            /**
             * Gets the value that a constant expression evaluates to.
             * @returns the value
             */
            get_value(): unknown;
        }

        namespace Constraint {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                constant: number;
                multiplier: number;
                relation: ConstraintRelation;
                source: ConstraintTarget;
                source_attribute: ConstraintAttribute;
                sourceAttribute: ConstraintAttribute;
                strength: number;
                target: ConstraintTarget;
                target_attribute: ConstraintAttribute;
                targetAttribute: ConstraintAttribute;
            }
        }

        /**
         * `GtkConstraint` describes a constraint between attributes of two widgets,
         *  expressed as a linear equation.
         *
         * The typical equation for a constraint is:
         *
         * ```
         *   target.target_attr = source.source_attr × multiplier + constant
         * ```
         *
         * Each `GtkConstraint` is part of a system that will be solved by a
         * [class`Gtk`.ConstraintLayout] in order to allocate and position each
         * child widget or guide.
         *
         * The source and target, as well as their attributes, of a `GtkConstraint`
         * instance are immutable after creation.
         */
        class Constraint extends GObject.Object {
            static $gtype: GObject.GType<Constraint>;

            // Properties

            /**
             * The constant value to be added to the [property`Gtk`.Constraint:source-attribute].
             */
            get constant(): number;
            /**
             * The multiplication factor to be applied to
             * the [property`Gtk`.Constraint:source-attribute].
             */
            get multiplier(): number;
            /**
             * The order relation between the terms of the constraint.
             */
            get relation(): ConstraintRelation;
            /**
             * The source of the constraint.
             *
             * The constraint will set the [property`Gtk`.Constraint:target-attribute]
             * property of the target using the [property`Gtk`.Constraint:source-attribute]
             * property of the source.
             */
            get source(): ConstraintTarget;
            /**
             * The attribute of the [property`Gtk`.Constraint:source] read by the
             * constraint.
             */
            get source_attribute(): ConstraintAttribute;
            /**
             * The attribute of the [property`Gtk`.Constraint:source] read by the
             * constraint.
             */
            get sourceAttribute(): ConstraintAttribute;
            /**
             * The strength of the constraint.
             *
             * The strength can be expressed either using one of the symbolic values
             * of the [enum`Gtk`.ConstraintStrength] enumeration, or any positive integer
             * value.
             */
            get strength(): number;
            /**
             * The target of the constraint.
             *
             * The constraint will set the [property`Gtk`.Constraint:target-attribute]
             * property of the target using the [property`Gtk`.Constraint:source-attribute]
             * property of the source widget.
             */
            get target(): ConstraintTarget;
            /**
             * The attribute of the [property`Gtk`.Constraint:target] set by the constraint.
             */
            get target_attribute(): ConstraintAttribute;
            /**
             * The attribute of the [property`Gtk`.Constraint:target] set by the constraint.
             */
            get targetAttribute(): ConstraintAttribute;

            // Constructors

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

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

            static ['new'](
                target: ConstraintTarget | null,
                target_attribute: ConstraintAttribute,
                relation: ConstraintRelation,
                source: ConstraintTarget | null,
                source_attribute: ConstraintAttribute,
                multiplier: number,
                constant: number,
                strength: number,
            ): Constraint;

            static new_constant(
                target: ConstraintTarget | null,
                target_attribute: ConstraintAttribute,
                relation: ConstraintRelation,
                constant: number,
                strength: number,
            ): Constraint;

            // Methods

            /**
             * Retrieves the constant factor added to the source attributes' value.
             * @returns a constant factor
             */
            get_constant(): number;
            /**
             * Retrieves the multiplication factor applied to the source
             * attribute's value.
             * @returns a multiplication factor
             */
            get_multiplier(): number;
            /**
             * The order relation between the terms of the constraint.
             * @returns a relation type
             */
            get_relation(): ConstraintRelation;
            /**
             * Retrieves the [iface`Gtk`.ConstraintTarget] used as the source for the
             * constraint.
             *
             * If the source is set to `NULL` at creation, the constraint will use
             * the widget using the [class`Gtk`.ConstraintLayout] as the source.
             * @returns the source of the constraint
             */
            get_source(): ConstraintTarget | null;
            /**
             * Retrieves the attribute of the source to be read by the constraint.
             * @returns the source's attribute
             */
            get_source_attribute(): ConstraintAttribute;
            /**
             * Retrieves the strength of the constraint.
             * @returns the strength value
             */
            get_strength(): number;
            /**
             * Retrieves the [iface`Gtk`.ConstraintTarget] used as the target for
             * the constraint.
             *
             * If the targe is set to `NULL` at creation, the constraint will use
             * the widget using the [class`Gtk`.ConstraintLayout] as the target.
             * @returns a `GtkConstraintTarget`
             */
            get_target(): ConstraintTarget | null;
            /**
             * Retrieves the attribute of the target to be set by the constraint.
             * @returns the target's attribute
             */
            get_target_attribute(): ConstraintAttribute;
            /**
             * Checks whether the constraint is attached to a [class`Gtk`.ConstraintLayout],
             * and it is contributing to the layout.
             * @returns `TRUE` if the constraint is attached
             */
            is_attached(): boolean;
            /**
             * Checks whether the constraint describes a relation between an attribute
             * on the [property`Gtk`.Constraint:target] and a constant value.
             * @returns `TRUE` if the constraint is a constant relation
             */
            is_constant(): boolean;
            /**
             * Checks whether the constraint is a required relation for solving the
             * constraint layout.
             * @returns %TRUE if the constraint is required
             */
            is_required(): boolean;
        }

        namespace ConstraintGuide {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps, ConstraintTarget.ConstructorProps {
                max_height: number;
                maxHeight: number;
                max_width: number;
                maxWidth: number;
                min_height: number;
                minHeight: number;
                min_width: number;
                minWidth: number;
                name: string;
                nat_height: number;
                natHeight: number;
                nat_width: number;
                natWidth: number;
                strength: ConstraintStrength;
            }
        }

        /**
         * A `GtkConstraintGuide` is an invisible layout element in a
         * `GtkConstraintLayout`.
         *
         * The `GtkConstraintLayout` treats guides like widgets. They
         * can be used as the source or target of a `GtkConstraint`.
         *
         * Guides have a minimum, maximum and natural size. Depending
         * on the constraints that are applied, they can act like a
         * guideline that widgets can be aligned to, or like *flexible
         * space*.
         *
         * Unlike a `GtkWidget`, a `GtkConstraintGuide` will not be drawn.
         */
        class ConstraintGuide extends GObject.Object implements ConstraintTarget {
            static $gtype: GObject.GType<ConstraintGuide>;

            // Properties

            /**
             * The maximum height of the guide.
             */
            get max_height(): number;
            set max_height(val: number);
            /**
             * The maximum height of the guide.
             */
            get maxHeight(): number;
            set maxHeight(val: number);
            /**
             * The maximum width of the guide.
             */
            get max_width(): number;
            set max_width(val: number);
            /**
             * The maximum width of the guide.
             */
            get maxWidth(): number;
            set maxWidth(val: number);
            /**
             * The minimum height of the guide.
             */
            get min_height(): number;
            set min_height(val: number);
            /**
             * The minimum height of the guide.
             */
            get minHeight(): number;
            set minHeight(val: number);
            /**
             * The minimum width of the guide.
             */
            get min_width(): number;
            set min_width(val: number);
            /**
             * The minimum width of the guide.
             */
            get minWidth(): number;
            set minWidth(val: number);
            /**
             * A name that identifies the `GtkConstraintGuide`, for debugging.
             */
            get name(): string;
            set name(val: string);
            /**
             * The preferred, or natural, height of the guide.
             */
            get nat_height(): number;
            set nat_height(val: number);
            /**
             * The preferred, or natural, height of the guide.
             */
            get natHeight(): number;
            set natHeight(val: number);
            /**
             * The preferred, or natural, width of the guide.
             */
            get nat_width(): number;
            set nat_width(val: number);
            /**
             * The preferred, or natural, width of the guide.
             */
            get natWidth(): number;
            set natWidth(val: number);
            /**
             * The `GtkConstraintStrength` to be used for the constraint on
             * the natural size of the guide.
             */
            get strength(): ConstraintStrength;
            set strength(val: ConstraintStrength);

            // Constructors

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

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

            static ['new'](): ConstraintGuide;

            // Methods

            /**
             * Gets the maximum size of `guide`.
             */
            get_max_size(): [number, number];
            /**
             * Gets the minimum size of `guide`.
             */
            get_min_size(): [number, number];
            /**
             * Retrieves the name set using gtk_constraint_guide_set_name().
             * @returns the name of the guide
             */
            get_name(): string | null;
            /**
             * Gets the natural size of `guide`.
             */
            get_nat_size(): [number, number];
            /**
             * Retrieves the strength set using gtk_constraint_guide_set_strength().
             * @returns the strength of the constraint on the natural size
             */
            get_strength(): ConstraintStrength;
            /**
             * Sets the maximum size of `guide`.
             *
             * If `guide` is attached to a `GtkConstraintLayout`,
             * the constraints will be updated to reflect the new size.
             * @param width the new maximum width, or -1 to not change it
             * @param height the new maximum height, or -1 to not change it
             */
            set_max_size(width: number, height: number): void;
            /**
             * Sets the minimum size of `guide`.
             *
             * If `guide` is attached to a `GtkConstraintLayout`,
             * the constraints will be updated to reflect the new size.
             * @param width the new minimum width, or -1 to not change it
             * @param height the new minimum height, or -1 to not change it
             */
            set_min_size(width: number, height: number): void;
            /**
             * Sets a name for the given `GtkConstraintGuide`.
             *
             * The name is useful for debugging purposes.
             * @param name a name for the @guide
             */
            set_name(name?: string | null): void;
            /**
             * Sets the natural size of `guide`.
             *
             * If `guide` is attached to a `GtkConstraintLayout`,
             * the constraints will be updated to reflect the new size.
             * @param width the new natural width, or -1 to not change it
             * @param height the new natural height, or -1 to not change it
             */
            set_nat_size(width: number, height: number): void;
            /**
             * Sets the strength of the constraint on the natural size of the
             * given `GtkConstraintGuide`.
             * @param strength the strength of the constraint
             */
            set_strength(strength: ConstraintStrength | null): void;

            // Inherited methods
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ConstraintLayout {
            // Constructor properties interface

            interface ConstructorProps extends LayoutManager.ConstructorProps, Buildable.ConstructorProps {}
        }

        /**
         * A layout manager using constraints to describe relations between widgets.
         *
         * `GtkConstraintLayout` is a layout manager that uses relations between
         * widget attributes, expressed via [class`Gtk`.Constraint] instances, to
         * measure and allocate widgets.
         *
         * ### How do constraints work
         *
         * Constraints are objects defining the relationship between attributes
         * of a widget; you can read the description of the [class`Gtk`.Constraint]
         * class to have a more in depth definition.
         *
         * By taking multiple constraints and applying them to the children of
         * a widget using `GtkConstraintLayout`, it's possible to describe
         * complex layout policies; each constraint applied to a child or to the parent
         * widgets contributes to the full description of the layout, in terms of
         * parameters for resolving the value of each attribute.
         *
         * It is important to note that a layout is defined by the totality of
         * constraints; removing a child, or a constraint, from an existing layout
         * without changing the remaining constraints may result in an unstable
         * or unsolvable layout.
         *
         * Constraints have an implicit "reading order"; you should start describing
         * each edge of each child, as well as their relationship with the parent
         * container, from the top left (or top right, in RTL languages), horizontally
         * first, and then vertically.
         *
         * A constraint-based layout with too few constraints can become "unstable",
         * that is: have more than one solution. The behavior of an unstable layout
         * is undefined.
         *
         * A constraint-based layout with conflicting constraints may be unsolvable,
         * and lead to an unstable layout. You can use the [property`Gtk`.Constraint:strength]
         * property of [class`Gtk`.Constraint] to "nudge" the layout towards a solution.
         *
         * ### GtkConstraintLayout as GtkBuildable
         *
         * `GtkConstraintLayout` implements the [iface`Gtk`.Buildable] interface and
         * has a custom "constraints" element which allows describing constraints in
         * a [class`Gtk`.Builder] UI file.
         *
         * An example of a UI definition fragment specifying a constraint:
         *
         * ```xml
         *   <object class="GtkConstraintLayout">
         *     <constraints>
         *       <constraint target="button" target-attribute="start"
         *                   relation="eq"
         *                   source="super" source-attribute="start"
         *                   constant="12"
         *                   strength="required" />
         *       <constraint target="button" target-attribute="width"
         *                   relation="ge"
         *                   constant="250"
         *                   strength="strong" />
         *     </constraints>
         *   </object>
         * ```
         *
         * The definition above will add two constraints to the GtkConstraintLayout:
         *
         *  - a required constraint between the leading edge of "button" and
         *    the leading edge of the widget using the constraint layout, plus
         *    12 pixels
         *  - a strong, constant constraint making the width of "button" greater
         *    than, or equal to 250 pixels
         *
         * The "target" and "target-attribute" attributes are required.
         *
         * The "source" and "source-attribute" attributes of the "constraint"
         * element are optional; if they are not specified, the constraint is
         * assumed to be a constant.
         *
         * The "relation" attribute is optional; if not specified, the constraint
         * is assumed to be an equality.
         *
         * The "strength" attribute is optional; if not specified, the constraint
         * is assumed to be required.
         *
         * The "source" and "target" attributes can be set to "super" to indicate
         * that the constraint target is the widget using the GtkConstraintLayout.
         *
         * There can be "constant" and "multiplier" attributes.
         *
         * Additionally, the "constraints" element can also contain a description
         * of the `GtkConstraintGuides` used by the layout:
         *
         * ```xml
         *   <constraints>
         *     <guide min-width="100" max-width="500" name="hspace"/>
         *     <guide min-height="64" nat-height="128" name="vspace" strength="strong"/>
         *   </constraints>
         * ```
         *
         * The "guide" element has the following optional attributes:
         *
         *   - "min-width", "nat-width", and "max-width", describe the minimum,
         *     natural, and maximum width of the guide, respectively
         *   - "min-height", "nat-height", and "max-height", describe the minimum,
         *     natural, and maximum height of the guide, respectively
         *   - "strength" describes the strength of the constraint on the natural
         *     size of the guide; if not specified, the constraint is assumed to
         *     have a medium strength
         *   - "name" describes a name for the guide, useful when debugging
         *
         * ### Using the Visual Format Language
         *
         * Complex constraints can be described using a compact syntax called VFL,
         * or *Visual Format Language*.
         *
         * The Visual Format Language describes all the constraints on a row or
         * column, typically starting from the leading edge towards the trailing
         * one. Each element of the layout is composed by "views", which identify
         * a [iface`Gtk`.ConstraintTarget].
         *
         * For instance:
         *
         * ```
         *   [button]-[textField]
         * ```
         *
         * Describes a constraint that binds the trailing edge of "button" to the
         * leading edge of "textField", leaving a default space between the two.
         *
         * Using VFL is also possible to specify predicates that describe constraints
         * on attributes like width and height:
         *
         * ```
         *   // Width must be greater than, or equal to 50
         *   [button(>=50)]
         *
         *   // Width of button1 must be equal to width of button2
         *   [button1(==button2)]
         * ```
         *
         * The default orientation for a VFL description is horizontal, unless
         * otherwise specified:
         *
         * ```
         *   // horizontal orientation, default attribute: width
         *   H:[button(>=150)]
         *
         *   // vertical orientation, default attribute: height
         *   V:[button1(==button2)]
         * ```
         *
         * It's also possible to specify multiple predicates, as well as their
         * strength:
         *
         * ```
         *   // minimum width of button must be 150
         *   // natural width of button can be 250
         *   [button(>=150`required,` ==250`medium)`]
         * ```
         *
         * Finally, it's also possible to use simple arithmetic operators:
         *
         * ```
         *   // width of button1 must be equal to width of button2
         *   // divided by 2 plus 12
         *   [button1(button2 / 2 + 12)]
         * ```
         */
        class ConstraintLayout extends LayoutManager implements Buildable {
            static $gtype: GObject.GType<ConstraintLayout>;

            // Constructors

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

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

            static ['new'](): ConstraintLayout;

            // Methods

            /**
             * Adds a constraint to the layout manager.
             *
             * The [property`Gtk`.Constraint:source] and [property`Gtk`.Constraint:target]
             * properties of `constraint` can be:
             *
             *  - set to `NULL` to indicate that the constraint refers to the
             *    widget using `layout`
             *  - set to the [class`Gtk`.Widget] using `layout`
             *  - set to a child of the [class`Gtk`.Widget] using `layout`
             *  - set to a [class`Gtk`.ConstraintGuide] that is part of `layout`
             *
             * The `layout` acquires the ownership of `constraint` after calling
             * this function.
             * @param constraint a [class@Gtk.Constraint]
             */
            add_constraint(constraint: Constraint): void;
            /**
             * Creates a list of constraints from a VFL description.
             *
             * The Visual Format Language, VFL, is based on Apple's AutoLayout [VFL](https://developer.apple.com/library/content/documentation/UserExperience/Conceptual/AutolayoutPG/VisualFormatLanguage.html).
             *
             * The `views` dictionary is used to match [iface`Gtk`.ConstraintTarget]
             * instances to the symbolic view name inside the VFL.
             *
             * The VFL grammar is:
             *
             * ```
             *        <visualFormatString> = (<orientation>)?
             *                               (<superview><connection>)?
             *                               <view>(<connection><view>)*
             *                               (<connection><superview>)?
             *               <orientation> = 'H' | 'V'
             *                 <superview> = '|'
             *                <connection> = '' | '-' <predicateList> '-' | '-'
             *             <predicateList> = <simplePredicate> | <predicateListWithParens>
             *           <simplePredicate> = <metricName> | <positiveNumber>
             *   <predicateListWithParens> = '(' <predicate> (',' <predicate>)* ')'
             *                 <predicate> = (<relation>)? <objectOfPredicate> (<operatorList>)? ('`'` <priority>)?
             *                  <relation> = '==' | '<=' | '>='
             *         <objectOfPredicate> = <constant> | <viewName> | ('.' <attributeName>)?
             *                  <priority> = <positiveNumber> | 'required' | 'strong' | 'medium' | 'weak'
             *                  <constant> = <number>
             *              <operatorList> = (<multiplyOperator>)? (<addOperator>)?
             *          <multiplyOperator> = [ '*' | '/' ] <positiveNumber>
             *               <addOperator> = [ '+' | '-' ] <positiveNumber>
             *                  <viewName> = [A-Za-z_]([A-Za-z0-9_]*) // A C identifier
             *                <metricName> = [A-Za-z_]([A-Za-z0-9_]*) // A C identifier
             *             <attributeName> = 'top' | 'bottom' | 'left' | 'right' | 'width' | 'height' |
             *                               'start' | 'end' | 'centerX' | 'centerY' | 'baseline'
             *            <positiveNumber> // A positive real number parseable by g_ascii_strtod()
             *                    <number> // A real number parseable by g_ascii_strtod()
             * ```
             *
             * **Note**: The VFL grammar used by GTK is slightly different than the one
             * defined by Apple, as it can use symbolic values for the constraint's
             * strength instead of numeric values; additionally, GTK allows adding
             * simple arithmetic operations inside predicates.
             *
             * Examples of VFL descriptions are:
             *
             * ```
             *   // Default spacing
             *   [button]-[textField]
             *
             *   // Width constraint
             *   [button(>=50)]
             *
             *   // Connection to super view
             *   |-50-[purpleBox]-50-|
             *
             *   // Vertical layout
             *   V:[topField]-10-[bottomField]
             *
             *   // Flush views
             *   [maroonView][blueView]
             *
             *   // Priority
             *   [button(100`strong)`]
             *
             *   // Equal widths
             *   [button1(==button2)]
             *
             *   // Multiple predicates
             *   [flexibleButton(>=70,<=100)]
             *
             *   // A complete line of layout
             *   |-[find]-[findNext]-[findField(>=20)]-|
             *
             *   // Operators
             *   [button1(button2 / 3 + 50)]
             *
             *   // Named attributes
             *   [button1(==button2.height)]
             * ```
             * @param lines an array of Visual Format Language lines   defining a set of constraints
             * @param hspacing default horizontal spacing value, or -1 for the fallback value
             * @param vspacing default vertical spacing value, or -1 for the fallback value
             * @param views a dictionary of `[ name, target ]`   pairs; the `name` keys map to the view names in the VFL lines, while   the `target` values map to children of the widget using a `GtkConstraintLayout`,   or guides
             * @returns the list of   [class@Gtk.Constraint] instances that were added to the layout
             */
            add_constraints_from_description(
                lines: string[],
                hspacing: number,
                vspacing: number,
                views: { [key: string]: any } | GLib.HashTable<string, ConstraintTarget>,
            ): Constraint[];
            /**
             * Adds a guide to `layout`.
             *
             * A guide can be used as the source or target of constraints,
             * like a widget, but it is not visible.
             *
             * The `layout` acquires the ownership of `guide` after calling
             * this function.
             * @param guide a [class@Gtk.ConstraintGuide] object
             */
            add_guide(guide: ConstraintGuide): void;
            /**
             * Returns a `GListModel` to track the constraints that are
             * part of the layout.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track constraints and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a   `GListModel` tracking the layout's constraints
             */
            observe_constraints(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the guides that are
             * part of the layout.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track guides and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a   `GListModel` tracking the layout's guides
             */
            observe_guides(): Gio.ListModel;
            /**
             * Removes all constraints from the layout manager.
             */
            remove_all_constraints(): void;
            /**
             * Removes `constraint` from the layout manager,
             * so that it no longer influences the layout.
             * @param constraint a [class@Gtk.Constraint]
             */
            remove_constraint(constraint: Constraint): void;
            /**
             * Removes `guide` from the layout manager,
             * so that it no longer influences the layout.
             * @param guide a [class@Gtk.ConstraintGuide] object
             */
            remove_guide(guide: ConstraintGuide): void;

            // Inherited methods
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ConstraintLayoutChild {
            // Constructor properties interface

            interface ConstructorProps extends LayoutChild.ConstructorProps {}
        }

        /**
         * `GtkLayoutChild` subclass for children in a `GtkConstraintLayout`.
         */
        class ConstraintLayoutChild extends LayoutChild {
            static $gtype: GObject.GType<ConstraintLayoutChild>;

            // Constructors

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

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

        namespace CssProvider {
            // Signal callback interfaces

            interface ParsingError {
                (section: CssSection, error: GLib.Error): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps, StyleProvider.ConstructorProps {}
        }

        /**
         * `GtkCssProvider` is an object implementing the `GtkStyleProvider` interface
         * for CSS.
         *
         * It is able to parse CSS-like input in order to style widgets.
         *
         * An application can make GTK parse a specific CSS style sheet by calling
         * [method`Gtk`.CssProvider.load_from_file] or
         * [method`Gtk`.CssProvider.load_from_resource]
         * and adding the provider with [method`Gtk`.StyleContext.add_provider] or
         * [func`Gtk`.StyleContext.add_provider_for_display].
         *
         * In addition, certain files will be read when GTK is initialized.
         * First, the file `$XDG_CONFIG_HOME/gtk-4.0/gtk.css` is loaded if it
         * exists. Then, GTK loads the first existing file among
         * `XDG_DATA_HOME/themes/THEME/gtk-VERSION/gtk-VARIANT.css`,
         * `$HOME/.themes/THEME/gtk-VERSION/gtk-VARIANT.css`,
         * `$XDG_DATA_DIRS/themes/THEME/gtk-VERSION/gtk-VARIANT.css` and
         * `DATADIR/share/themes/THEME/gtk-VERSION/gtk-VARIANT.css`,
         * where `THEME` is the name of the current theme (see the
         * [property`Gtk`.Settings:gtk-theme-name] setting), `VARIANT` is the
         * variant to load (see the
         * [property`Gtk`.Settings:gtk-application-prefer-dark-theme] setting),
         * `DATADIR` is the prefix configured when GTK was compiled (unless
         * overridden by the `GTK_DATA_PREFIX` environment variable), and
         * `VERSION` is the GTK version number. If no file is found for the
         * current version, GTK tries older versions all the way back to 4.0.
         *
         * To track errors while loading CSS, connect to the
         * [signal`Gtk`.CssProvider::parsing-error] signal.
         */
        class CssProvider extends GObject.Object implements StyleProvider {
            static $gtype: GObject.GType<CssProvider>;

            // Constructors

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

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

            static ['new'](): CssProvider;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(
                signal: 'parsing-error',
                callback: (_source: this, section: CssSection, error: GLib.Error) => void,
            ): number;
            connect_after(
                signal: 'parsing-error',
                callback: (_source: this, section: CssSection, error: GLib.Error) => void,
            ): number;
            emit(signal: 'parsing-error', section: CssSection, error: GLib.Error): void;

            // Methods

            /**
             * Loads `data` into `css_provider`.
             *
             * This clears any previously loaded information.
             * @param data `GBytes` containing the data to load
             */
            load_from_bytes(data: GLib.Bytes | Uint8Array): void;
            /**
             * Loads `data` into `css_provider`.
             *
             * This clears any previously loaded information.
             * @param data CSS data to be parsed
             * @param length the length of @data in bytes, or -1 for NUL terminated strings
             */
            load_from_data(data: string, length: number): void;
            /**
             * Loads the data contained in `file` into `css_provider`.
             *
             * This clears any previously loaded information.
             * @param file `GFile` pointing to a file to load
             */
            load_from_file(file: Gio.File): void;
            /**
             * Loads the data contained in `path` into `css_provider`.
             *
             * This clears any previously loaded information.
             * @param path the path of a filename to load, in the GLib filename encoding
             */
            load_from_path(path: string): void;
            /**
             * Loads the data contained in the resource at `resource_path` into
             * the `css_provider`.
             *
             * This clears any previously loaded information.
             * @param resource_path a `GResource` resource path
             */
            load_from_resource(resource_path: string): void;
            /**
             * Loads `string` into `css_provider`.
             *
             * This clears any previously loaded information.
             * @param string the CSS to load
             */
            load_from_string(string: string): void;
            /**
             * Loads a theme from the usual theme paths.
             *
             * The actual process of finding the theme might change between
             * releases, but it is guaranteed that this function uses the same
             * mechanism to load the theme that GTK uses for loading its own theme.
             * @param name A theme name
             * @param variant variant to load, for example, "dark", or   %NULL for the default
             */
            load_named(name: string, variant?: string | null): void;
            /**
             * Converts the `provider` into a string representation in CSS
             * format.
             *
             * Using [method`Gtk`.CssProvider.load_from_string] with the return
             * value from this function on a new provider created with
             * [ctor`Gtk`.CssProvider.new] will basically create a duplicate
             * of this `provider`.
             * @returns a new string representing the @provider.
             */
            to_string(): string;

            // Inherited methods
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace CustomFilter {
            // Constructor properties interface

            interface ConstructorProps extends Filter.ConstructorProps {}
        }

        /**
         * `GtkCustomFilter` determines whether to include items with a callback.
         */
        class CustomFilter extends Filter {
            static $gtype: GObject.GType<CustomFilter>;

            // Constructors

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

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

            static ['new'](match_func?: CustomFilterFunc | null): CustomFilter;

            // Methods

            /**
             * Sets the function used for filtering items.
             *
             * If `match_func` is %NULL, the filter matches all items.
             *
             * If the filter func changes its filtering behavior,
             * gtk_filter_changed() needs to be called.
             *
             * If a previous function was set, its `user_destroy` will be
             * called now.
             * @param match_func function to filter items
             */
            set_filter_func(match_func?: CustomFilterFunc | null): void;
        }

        namespace CustomLayout {
            // Constructor properties interface

            interface ConstructorProps extends LayoutManager.ConstructorProps {}
        }

        /**
         * `GtkCustomLayout` uses closures for size negotiation.
         *
         * A `GtkCustomLayout `uses closures matching to the old `GtkWidget`
         * virtual functions for size negotiation, as a convenience API to
         * ease the porting towards the corresponding `GtkLayoutManager
         * virtual functions.
         */
        class CustomLayout extends LayoutManager {
            static $gtype: GObject.GType<CustomLayout>;

            // Constructors

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

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

            static ['new'](
                request_mode: CustomRequestModeFunc | null,
                measure: CustomMeasureFunc,
                allocate: CustomAllocateFunc,
            ): CustomLayout;
        }

        namespace CustomSorter {
            // Constructor properties interface

            interface ConstructorProps extends Sorter.ConstructorProps {}
        }

        /**
         * `GtkCustomSorter` is a `GtkSorter` implementation that sorts via a callback
         * function.
         */
        class CustomSorter extends Sorter {
            static $gtype: GObject.GType<CustomSorter>;

            // Constructors

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

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

            static ['new'](
                sort_func?: GLib.CompareDataFunc | null,
                user_destroy?: GLib.DestroyNotify | null,
            ): CustomSorter;

            // Methods

            /**
             * Sets (or unsets) the function used for sorting items.
             *
             * If `sort_func` is %NULL, all items are considered equal.
             *
             * If the sort func changes its sorting behavior,
             * gtk_sorter_changed() needs to be called.
             *
             * If a previous function was set, its `user_destroy` will be
             * called now.
             * @param sort_func function to sort items
             */
            set_sort_func(sort_func?: GLib.CompareDataFunc | null): void;
        }

        namespace Dialog {
            // Signal callback interfaces

            interface Close {
                (): void;
            }

            interface Response {
                (response_id: number): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Window.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Native.ConstructorProps,
                    Root.ConstructorProps,
                    ShortcutManager.ConstructorProps {
                use_header_bar: number;
                useHeaderBar: number;
            }
        }

        /**
         * Dialogs are a convenient way to prompt the user for a small amount
         * of input.
         *
         * ![An example GtkDialog](dialog.png)
         *
         * Typical uses are to display a message, ask a question, or anything else
         * that does not require extensive effort on the user’s part.
         *
         * The main area of a `GtkDialog` is called the "content area", and is yours
         * to populate with widgets such a `GtkLabel` or `GtkEntry`, to present
         * your information, questions, or tasks to the user.
         *
         * In addition, dialogs allow you to add "action widgets". Most commonly,
         * action widgets are buttons. Depending on the platform, action widgets may
         * be presented in the header bar at the top of the window, or at the bottom
         * of the window. To add action widgets, create your `GtkDialog` using
         * [ctor`Gtk`.Dialog.new_with_buttons], or use
         * [method`Gtk`.Dialog.add_button], [method`Gtk`.Dialog.add_buttons],
         * or [method`Gtk`.Dialog.add_action_widget].
         *
         * `GtkDialogs` uses some heuristics to decide whether to add a close
         * button to the window decorations. If any of the action buttons use
         * the response ID %GTK_RESPONSE_CLOSE or %GTK_RESPONSE_CANCEL, the
         * close button is omitted.
         *
         * Clicking a button that was added as an action widget will emit the
         * [signal`Gtk`.Dialog::response] signal with a response ID that you specified.
         * GTK will never assign a meaning to positive response IDs; these are
         * entirely user-defined. But for convenience, you can use the response
         * IDs in the [enum`Gtk`.ResponseType] enumeration (these all have values
         * less than zero). If a dialog receives a delete event, the
         * [signal`Gtk`.Dialog::response] signal will be emitted with the
         * %GTK_RESPONSE_DELETE_EVENT response ID.
         *
         * Dialogs are created with a call to [ctor`Gtk`.Dialog.new] or
         * [ctor`Gtk`.Dialog.new_with_buttons]. The latter is recommended; it allows
         * you to set the dialog title, some convenient flags, and add buttons.
         *
         * A “modal” dialog (that is, one which freezes the rest of the application
         * from user input), can be created by calling [method`Gtk`.Window.set_modal]
         * on the dialog. When using [ctor`Gtk`.Dialog.new_with_buttons], you can also
         * pass the %GTK_DIALOG_MODAL flag to make a dialog modal.
         *
         * For the simple dialog in the following example, a [class`Gtk`.MessageDialog]
         * would save some effort. But you’d need to create the dialog contents manually
         * if you had more than a simple message in the dialog.
         *
         * An example for simple `GtkDialog` usage:
         *
         * ```c
         * // Function to open a dialog box with a message
         * void
         * quick_message (GtkWindow *parent, char *message)
         * {
         *  GtkWidget *dialog, *label, *content_area;
         *  GtkDialogFlags flags;
         *
         *  // Create the widgets
         *  flags = GTK_DIALOG_DESTROY_WITH_PARENT;
         *  dialog = gtk_dialog_new_with_buttons ("Message",
         *                                        parent,
         *                                        flags,
         *                                        _("_OK"),
         *                                        GTK_RESPONSE_NONE,
         *                                        NULL);
         *  content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
         *  label = gtk_label_new (message);
         *
         *  // Ensure that the dialog box is destroyed when the user responds
         *
         *  g_signal_connect_swapped (dialog,
         *                            "response",
         *                            G_CALLBACK (gtk_window_destroy),
         *                            dialog);
         *
         *  // Add the label, and show everything we’ve added
         *
         *  gtk_box_append (GTK_BOX (content_area), label);
         *  gtk_widget_show (dialog);
         * }
         * ```
         *
         * # GtkDialog as GtkBuildable
         *
         * The `GtkDialog` implementation of the `GtkBuildable` interface exposes the
         * `content_area` as an internal child with the name “content_area”.
         *
         * `GtkDialog` supports a custom `<action-widgets>` element, which can contain
         * multiple `<action-widget>` elements. The “response” attribute specifies a
         * numeric response, and the content of the element is the id of widget
         * (which should be a child of the dialogs `action_area)`. To mark a response
         * as default, set the “default” attribute of the `<action-widget>` element
         * to true.
         *
         * `GtkDialog` supports adding action widgets by specifying “action” as
         * the “type” attribute of a `<child>` element. The widget will be added
         * either to the action area or the headerbar of the dialog, depending
         * on the “use-header-bar” property. The response id has to be associated
         * with the action widget using the `<action-widgets>` element.
         *
         * An example of a `GtkDialog` UI definition fragment:
         *
         * ```xml
         * <object class="GtkDialog" id="dialog1">
         *   <child type="action">
         *     <object class="GtkButton" id="button_cancel"/>
         *   </child>
         *   <child type="action">
         *     <object class="GtkButton" id="button_ok">
         *     </object>
         *   </child>
         *   <action-widgets>
         *     <action-widget response="cancel">button_cancel</action-widget>
         *     <action-widget response="ok" default="true">button_ok</action-widget>
         *   </action-widgets>
         * </object>
         * ```
         *
         * # Accessibility
         *
         * `GtkDialog` uses the %GTK_ACCESSIBLE_ROLE_DIALOG role.
         */
        class Dialog extends Window implements Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager {
            static $gtype: GObject.GType<Dialog>;

            // Properties

            /**
             * %TRUE if the dialog uses a headerbar for action buttons
             * instead of the action-area.
             *
             * For technical reasons, this property is declared as an integer
             * property, but you should only set it to %TRUE or %FALSE.
             *
             * ## Creating a dialog with headerbar
             *
             * Builtin `GtkDialog` subclasses such as [class`Gtk`.ColorChooserDialog]
             * set this property according to platform conventions (using the
             * [property`Gtk`.Settings:gtk-dialogs-use-header] setting).
             *
             * Here is how you can achieve the same:
             *
             * ```c
             * g_object_get (settings, "gtk-dialogs-use-header", &header, NULL);
             * dialog = g_object_new (GTK_TYPE_DIALOG, header, TRUE, NULL);
             * ```
             */
            get use_header_bar(): number;
            /**
             * %TRUE if the dialog uses a headerbar for action buttons
             * instead of the action-area.
             *
             * For technical reasons, this property is declared as an integer
             * property, but you should only set it to %TRUE or %FALSE.
             *
             * ## Creating a dialog with headerbar
             *
             * Builtin `GtkDialog` subclasses such as [class`Gtk`.ColorChooserDialog]
             * set this property according to platform conventions (using the
             * [property`Gtk`.Settings:gtk-dialogs-use-header] setting).
             *
             * Here is how you can achieve the same:
             *
             * ```c
             * g_object_get (settings, "gtk-dialogs-use-header", &header, NULL);
             * dialog = g_object_new (GTK_TYPE_DIALOG, header, TRUE, NULL);
             * ```
             */
            get useHeaderBar(): number;

            // Constructors

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

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

            static ['new'](): Dialog;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'close', callback: (_source: this) => void): number;
            connect_after(signal: 'close', callback: (_source: this) => void): number;
            emit(signal: 'close'): void;
            connect(signal: 'response', callback: (_source: this, response_id: number) => void): number;
            connect_after(signal: 'response', callback: (_source: this, response_id: number) => void): number;
            emit(signal: 'response', response_id: number): void;

            // Virtual methods

            /**
             * Signal emitted when the user uses a keybinding to close the dialog.
             */
            vfunc_close(): void;
            /**
             * Emits the ::response signal with the given response ID.
             *
             * Used to indicate that the user has responded to the dialog in some way.
             * @param response_id response ID
             */
            vfunc_response(response_id: number): void;

            // Methods

            /**
             * Adds an activatable widget to the action area of a `GtkDialog`.
             *
             * GTK connects a signal handler that will emit the
             * [signal`Gtk`.Dialog::response] signal on the dialog when the widget
             * is activated. The widget is appended to the end of the dialog’s action
             * area.
             *
             * If you want to add a non-activatable widget, simply pack it into
             * the `action_area` field of the `GtkDialog` struct.
             * @param child an activatable widget
             * @param response_id response ID for @child
             */
            add_action_widget(child: Widget, response_id: number): void;
            /**
             * Adds a button with the given text.
             *
             * GTK arranges things so that clicking the button will emit the
             * [signal`Gtk`.Dialog::response] signal with the given `response_id`.
             * The button is appended to the end of the dialog’s action area.
             * The button widget is returned, but usually you don’t need it.
             * @param button_text text of button
             * @param response_id response ID for the button
             * @returns the `GtkButton` widget that was added
             */
            add_button(button_text: string, response_id: number): Widget;
            /**
             * Returns the content area of `dialog`.
             * @returns the content area `GtkBox`.
             */
            get_content_area(): Box;
            /**
             * Returns the header bar of `dialog`.
             *
             * Note that the headerbar is only used by the dialog if the
             * [property`Gtk`.Dialog:use-header-bar] property is %TRUE.
             * @returns the header bar
             */
            get_header_bar(): HeaderBar;
            /**
             * Gets the response id of a widget in the action area
             * of a dialog.
             * @param widget a widget in the action area of @dialog
             * @returns the response id of @widget, or %GTK_RESPONSE_NONE  if @widget doesn’t have a response id set.
             */
            get_response_for_widget(widget: Widget): number;
            /**
             * Gets the widget button that uses the given response ID in the action area
             * of a dialog.
             * @param response_id the response ID used by the @dialog widget
             * @returns the @widget button that uses the given   @response_id
             */
            get_widget_for_response(response_id: number): Widget | null;
            /**
             * Emits the ::response signal with the given response ID.
             *
             * Used to indicate that the user has responded to the dialog in some way.
             * @param response_id response ID
             */
            response(response_id: number): void;
            /**
             * Sets the default widget for the dialog based on the response ID.
             *
             * Pressing “Enter” normally activates the default widget.
             * @param response_id a response ID
             */
            set_default_response(response_id: number): void;
            /**
             * A convenient way to sensitize/desensitize dialog buttons.
             *
             * Calls `gtk_widget_set_sensitive (widget, `setting)``
             * for each widget in the dialog’s action area with the given `response_id`.
             * @param response_id a response ID
             * @param setting %TRUE for sensitive
             */
            set_response_sensitive(response_id: number, setting: boolean): void;

            // Inherited properties
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Returns the renderer that is used for this `GtkNative`.
             * @returns the renderer for @self
             */
            get_renderer(): Gsk.Renderer | null;
            /**
             * Returns the surface of this `GtkNative`.
             * @returns the surface of @self
             */
            get_surface(): Gdk.Surface | null;
            /**
             * Retrieves the surface transform of `self`.
             *
             * This is the translation from `self'`s surface coordinates into
             * `self'`s widget coordinates.
             */
            get_surface_transform(): [number, number];
            /**
             * Realizes a `GtkNative`.
             *
             * This should only be used by subclasses.
             */
            realize(): void;
            /**
             * Unrealizes a `GtkNative`.
             *
             * This should only be used by subclasses.
             */
            unrealize(): void;
            /**
             * Returns the display that this `GtkRoot` is on.
             * @returns the display of @root
             */
            get_display(): Gdk.Display;
            /**
             * Retrieves the current focused widget within the root.
             *
             * Note that this is the widget that would have the focus
             * if the root is active; if the root is not focused then
             * `gtk_widget_has_focus (widget)` will be %FALSE for the
             * widget.
             * @returns the currently focused widget
             */
            get_focus(): Widget | null;
            /**
             * If `focus` is not the current focus widget, and is focusable, sets
             * it as the focus widget for the root.
             *
             * If `focus` is %NULL, unsets the focus widget for the root.
             *
             * To set the focus to a particular widget in the root, it is usually
             * more convenient to use [method`Gtk`.Widget.grab_focus] instead of
             * this function.
             * @param focus widget to be the new focus widget, or %NULL    to unset the focus widget
             */
            set_focus(focus?: Widget | null): void;
            /**
             * Add a `GtkShortcutController` to be managed.
             * @param controller
             */
            vfunc_add_controller(controller: ShortcutController): void;
            /**
             * Remove a `GtkShortcutController` that had previously
             *   been added
             * @param controller
             */
            vfunc_remove_controller(controller: ShortcutController): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace DirectoryList {
            // Constructor properties interface

            interface ConstructorProps<A extends GObject.Object = GObject.Object>
                extends GObject.Object.ConstructorProps,
                    Gio.ListModel.ConstructorProps {
                attributes: string;
                error: GLib.Error;
                file: Gio.File;
                io_priority: number;
                ioPriority: number;
                item_type: GObject.GType;
                itemType: GObject.GType;
                loading: boolean;
                monitored: boolean;
                n_items: number;
                nItems: number;
            }
        }

        /**
         * `GtkDirectoryList` is a list model that wraps g_file_enumerate_children_async().
         *
         * It presents a `GListModel` and fills it asynchronously with the `GFileInfo`s
         * returned from that function.
         *
         * Enumeration will start automatically when the
         * [property`Gtk`.DirectoryList:file] property is set.
         *
         * While the `GtkDirectoryList` is being filled, the
         * [property`Gtk`.DirectoryList:loading] property will be set to %TRUE. You can
         * listen to that property if you want to show information like a `GtkSpinner`
         * or a "Loading..." text.
         *
         * If loading fails at any point, the [property`Gtk`.DirectoryList:error]
         * property will be set to give more indication about the failure.
         *
         * The `GFileInfo`s returned from a `GtkDirectoryList` have the "standard::file"
         * attribute set to the `GFile` they refer to. This way you can get at the file
         * that is referred to in the same way you would via g_file_enumerator_get_child().
         * This means you do not need access to the `GtkDirectoryList`, but can access
         * the `GFile` directly from the `GFileInfo` when operating with a `GtkListView`
         * or similar.
         */
        class DirectoryList<A extends GObject.Object = GObject.Object>
            extends GObject.Object
            implements Gio.ListModel<A>
        {
            static $gtype: GObject.GType<DirectoryList>;

            // Properties

            /**
             * The attributes to query.
             */
            get attributes(): string;
            set attributes(val: string);
            /**
             * Error encountered while loading files.
             */
            get error(): GLib.Error;
            /**
             * File to query.
             */
            get file(): Gio.File;
            set file(val: Gio.File);
            /**
             * Priority used when loading.
             */
            get io_priority(): number;
            set io_priority(val: number);
            /**
             * Priority used when loading.
             */
            get ioPriority(): number;
            set ioPriority(val: number);
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get item_type(): GObject.GType;
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get itemType(): GObject.GType;
            /**
             * %TRUE if files are being loaded.
             */
            get loading(): boolean;
            /**
             * %TRUE if the directory is monitored for changed.
             */
            get monitored(): boolean;
            set monitored(val: boolean);
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get n_items(): number;
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get nItems(): number;

            // Constructors

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

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

            static ['new'](attributes?: string | null, file?: Gio.File | null): DirectoryList;

            // Methods

            /**
             * Gets the attributes queried on the children.
             * @returns The queried attributes
             */
            get_attributes(): string | null;
            /**
             * Gets the loading error, if any.
             *
             * If an error occurs during the loading process, the loading process
             * will finish and this property allows querying the error that happened.
             * This error will persist until a file is loaded again.
             *
             * An error being set does not mean that no files were loaded, and all
             * successfully queried files will remain in the list.
             * @returns The loading error or %NULL if   loading finished successfully
             */
            get_error(): GLib.Error | null;
            /**
             * Gets the file whose children are currently enumerated.
             * @returns The file whose children are enumerated
             */
            get_file(): Gio.File | null;
            /**
             * Gets the IO priority set via gtk_directory_list_set_io_priority().
             * @returns The IO priority.
             */
            get_io_priority(): number;
            /**
             * Returns whether the directory list is monitoring
             * the directory for changes.
             * @returns %TRUE if the directory is monitored
             */
            get_monitored(): boolean;
            /**
             * Returns %TRUE if the children enumeration is currently in
             * progress.
             *
             * Files will be added to `self` from time to time while loading is
             * going on. The order in which are added is undefined and may change
             * in between runs.
             * @returns %TRUE if @self is loading
             */
            is_loading(): boolean;
            /**
             * Sets the `attributes` to be enumerated and starts the enumeration.
             *
             * If `attributes` is %NULL, the list of file infos will still be created, it will just
             * not contain any extra attributes.
             * @param attributes the attributes to enumerate
             */
            set_attributes(attributes?: string | null): void;
            /**
             * Sets the `file` to be enumerated and starts the enumeration.
             *
             * If `file` is %NULL, the result will be an empty list.
             * @param file the `GFile` to be enumerated
             */
            set_file(file?: Gio.File | null): void;
            /**
             * Sets the IO priority to use while loading directories.
             *
             * Setting the priority while `self` is loading will reprioritize the
             * ongoing load as soon as possible.
             *
             * The default IO priority is %G_PRIORITY_DEFAULT, which is higher than
             * the GTK redraw priority. If you are loading a lot of directories in
             * parallel, lowering it to something like %G_PRIORITY_DEFAULT_IDLE
             * may increase responsiveness.
             * @param io_priority IO priority to use
             */
            set_io_priority(io_priority: number): void;
            /**
             * Sets whether the directory list will monitor the directory
             * for changes.
             *
             * If monitoring is enabled, the ::items-changed signal will
             * be emitted when the directory contents change.
             *
             *
             * When monitoring is turned on after the initial creation
             * of the directory list, the directory is reloaded to avoid
             * missing files that appeared between the initial loading
             * and when monitoring was turned on.
             * @param monitored %TRUE to monitor the directory for changes
             */
            set_monitored(monitored: boolean): void;

            // Inherited methods
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             * @returns the #GType of the items contained in @list.
             */
            get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             * @returns the number of items in @list.
             */
            get_n_items(): number;
            /**
             * Get the item at `position`.
             *
             * If `position` is greater than the number of items in `list,` %NULL is
             * returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.
             *
             * This function is meant to be used by language bindings in place
             * of g_list_model_get_item().
             *
             * See also: g_list_model_get_n_items()
             * @param position the position of the item to fetch
             * @returns the object at @position.
             */
            get_item(position: number): A | null;
            /**
             * Emits the #GListModel::items-changed signal on `list`.
             *
             * This function should only be called by classes implementing
             * #GListModel. It has to be called after the internal representation
             * of `list` has been updated, because handlers connected to this signal
             * might query the new state of the list.
             *
             * Implementations must only make changes to the model (as visible to
             * its consumer) in places that will not cause problems for that
             * consumer.  For models that are driven directly by a write API (such
             * as #GListStore), changes can be reported in response to uses of that
             * API.  For models that represent remote data, changes should only be
             * made from a fresh mainloop dispatch.  It is particularly not
             * permitted to make changes in response to a call to the #GListModel
             * consumer API.
             *
             * Stated another way: in general, it is assumed that code making a
             * series of accesses to the model via the API, without returning to the
             * mainloop, and without calling other code, will continue to view the
             * same contents of the model.
             * @param position the position at which @list changed
             * @param removed the number of items removed
             * @param added the number of items added
             */
            items_changed(position: number, removed: number, added: number): void;
            /**
             * Get the item at `position`. If `position` is greater than the number of
             * items in `list,` %NULL is returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.  See g_list_model_get_n_items().
             *
             * The same #GObject instance may not appear more than once in a #GListModel.
             * @param position the position of the item to fetch
             */
            vfunc_get_item(position: number): A | null;
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             */
            vfunc_get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             */
            vfunc_get_n_items(): number;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace DragIcon {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Native.ConstructorProps,
                    Root.ConstructorProps {
                child: Widget;
            }
        }

        /**
         * `GtkDragIcon` is a `GtkRoot` implementation for drag icons.
         *
         * A drag icon moves with the pointer during a Drag-and-Drop operation
         * and is destroyed when the drag ends.
         *
         * To set up a drag icon and associate it with an ongoing drag operation,
         * use [ctor`Gtk`.DragIcon.get_for_drag] to get the icon for a drag. You can
         * then use it like any other widget and use [method`Gtk`.DragIcon.set_child]
         * to set whatever widget should be used for the drag icon.
         *
         * Keep in mind that drag icons do not allow user input.
         */
        class DragIcon extends Widget implements Accessible, Buildable, ConstraintTarget, Native, Root {
            static $gtype: GObject.GType<DragIcon>;

            // Properties

            /**
             * The widget to display as drag icon.
             */
            get child(): Widget;
            set child(val: Widget);

            // Constructors

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

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

            static get_for_drag(drag: Gdk.Drag): DragIcon;

            // Static methods

            /**
             * Creates a widget that can be used as a drag icon for the given
             * `value`.
             *
             * Supported types include strings, `GdkRGBA` and `GtkTextBuffer`.
             * If GTK does not know how to create a widget for a given value,
             * it will return %NULL.
             *
             * This method is used to set the default drag icon on drag-and-drop
             * operations started by `GtkDragSource`, so you don't need to set
             * a drag icon using this function there.
             * @param value a `GValue`
             */
            static create_widget_for_value(value: GObject.Value | any): Widget | null;
            /**
             * Creates a `GtkDragIcon` that shows `paintable,` and associates
             * it with the drag operation.
             *
             * The hotspot position on the paintable is aligned with the
             * hotspot of the cursor.
             * @param drag a `GdkDrag`
             * @param paintable a `GdkPaintable` to display
             * @param hot_x X coordinate of the hotspot
             * @param hot_y Y coordinate of the hotspot
             */
            static set_from_paintable(drag: Gdk.Drag, paintable: Gdk.Paintable, hot_x: number, hot_y: number): void;

            // Methods

            /**
             * Gets the widget currently used as drag icon.
             * @returns The drag icon
             */
            get_child(): Widget | null;
            /**
             * Sets the widget to display as the drag icon.
             * @param child a `GtkWidget`
             */
            set_child(child?: Widget | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Returns the renderer that is used for this `GtkNative`.
             * @returns the renderer for @self
             */
            get_renderer(): Gsk.Renderer | null;
            /**
             * Returns the surface of this `GtkNative`.
             * @returns the surface of @self
             */
            get_surface(): Gdk.Surface | null;
            /**
             * Retrieves the surface transform of `self`.
             *
             * This is the translation from `self'`s surface coordinates into
             * `self'`s widget coordinates.
             */
            get_surface_transform(): [number, number];
            /**
             * Realizes a `GtkNative`.
             *
             * This should only be used by subclasses.
             */
            realize(): void;
            /**
             * Unrealizes a `GtkNative`.
             *
             * This should only be used by subclasses.
             */
            unrealize(): void;
            /**
             * Returns the display that this `GtkRoot` is on.
             * @returns the display of @root
             */
            get_display(): Gdk.Display;
            /**
             * Retrieves the current focused widget within the root.
             *
             * Note that this is the widget that would have the focus
             * if the root is active; if the root is not focused then
             * `gtk_widget_has_focus (widget)` will be %FALSE for the
             * widget.
             * @returns the currently focused widget
             */
            get_focus(): Widget | null;
            /**
             * If `focus` is not the current focus widget, and is focusable, sets
             * it as the focus widget for the root.
             *
             * If `focus` is %NULL, unsets the focus widget for the root.
             *
             * To set the focus to a particular widget in the root, it is usually
             * more convenient to use [method`Gtk`.Widget.grab_focus] instead of
             * this function.
             * @param focus widget to be the new focus widget, or %NULL    to unset the focus widget
             */
            set_focus(focus?: Widget | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace DragSource {
            // Signal callback interfaces

            interface DragBegin {
                (drag: Gdk.Drag): void;
            }

            interface DragCancel {
                (drag: Gdk.Drag, reason: Gdk.DragCancelReason): boolean;
            }

            interface DragEnd {
                (drag: Gdk.Drag, delete_data: boolean): void;
            }

            interface Prepare {
                (x: number, y: number): Gdk.ContentProvider | null;
            }

            // Constructor properties interface

            interface ConstructorProps extends GestureSingle.ConstructorProps {
                actions: Gdk.DragAction;
                content: Gdk.ContentProvider;
            }
        }

        /**
         * `GtkDragSource` is an event controller to initiate Drag-And-Drop operations.
         *
         * `GtkDragSource` can be set up with the necessary
         * ingredients for a DND operation ahead of time. This includes
         * the source for the data that is being transferred, in the form
         * of a [class`Gdk`.ContentProvider], the desired action, and the icon to
         * use during the drag operation. After setting it up, the drag
         * source must be added to a widget as an event controller, using
         * [method`Gtk`.Widget.add_controller].
         *
         * ```c
         * static void
         * my_widget_init (MyWidget *self)
         * {
         *   GtkDragSource *drag_source = gtk_drag_source_new ();
         *
         *   g_signal_connect (drag_source, "prepare", G_CALLBACK (on_drag_prepare), self);
         *   g_signal_connect (drag_source, "drag-begin", G_CALLBACK (on_drag_begin), self);
         *
         *   gtk_widget_add_controller (GTK_WIDGET (self), GTK_EVENT_CONTROLLER (drag_source));
         * }
         * ```
         *
         * Setting up the content provider and icon ahead of time only makes
         * sense when the data does not change. More commonly, you will want
         * to set them up just in time. To do so, `GtkDragSource` has
         * [signal`Gtk`.DragSource::prepare] and [signal`Gtk`.DragSource::drag-begin]
         * signals.
         *
         * The ::prepare signal is emitted before a drag is started, and
         * can be used to set the content provider and actions that the
         * drag should be started with.
         *
         * ```c
         * static GdkContentProvider *
         * on_drag_prepare (GtkDragSource *source,
         *                  double         x,
         *                  double         y,
         *                  MyWidget      *self)
         * {
         *   // This widget supports two types of content: GFile objects
         *   // and GdkPixbuf objects; GTK will handle the serialization
         *   // of these types automatically
         *   GFile *file = my_widget_get_file (self);
         *   GdkPixbuf *pixbuf = my_widget_get_pixbuf (self);
         *
         *   return gdk_content_provider_new_union ((GdkContentProvider *[2]) {
         *       gdk_content_provider_new_typed (G_TYPE_FILE, file),
         *       gdk_content_provider_new_typed (GDK_TYPE_PIXBUF, pixbuf),
         *     }, 2);
         * }
         * ```
         *
         * The ::drag-begin signal is emitted after the `GdkDrag` object has
         * been created, and can be used to set up the drag icon.
         *
         * ```c
         * static void
         * on_drag_begin (GtkDragSource *source,
         *                GdkDrag       *drag,
         *                MyWidget      *self)
         * {
         *   // Set the widget as the drag icon
         *   GdkPaintable *paintable = gtk_widget_paintable_new (GTK_WIDGET (self));
         *   gtk_drag_source_set_icon (source, paintable, 0, 0);
         *   g_object_unref (paintable);
         * }
         * ```
         *
         * During the DND operation, `GtkDragSource` emits signals that
         * can be used to obtain updates about the status of the operation,
         * but it is not normally necessary to connect to any signals,
         * except for one case: when the supported actions include
         * %GDK_ACTION_MOVE, you need to listen for the
         * [signal`Gtk`.DragSource::drag-end] signal and delete the
         * data after it has been transferred.
         */
        class DragSource extends GestureSingle {
            static $gtype: GObject.GType<DragSource>;

            // Properties

            /**
             * The actions that are supported by drag operations from the source.
             *
             * Note that you must handle the [signal`Gtk`.DragSource::drag-end] signal
             * if the actions include %GDK_ACTION_MOVE.
             */
            get actions(): Gdk.DragAction;
            set actions(val: Gdk.DragAction);
            /**
             * The data that is offered by drag operations from this source.
             */
            get content(): Gdk.ContentProvider;
            set content(val: Gdk.ContentProvider);

            // Constructors

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

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

            static ['new'](): DragSource;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'drag-begin', callback: (_source: this, drag: Gdk.Drag) => void): number;
            connect_after(signal: 'drag-begin', callback: (_source: this, drag: Gdk.Drag) => void): number;
            emit(signal: 'drag-begin', drag: Gdk.Drag): void;
            connect(
                signal: 'drag-cancel',
                callback: (_source: this, drag: Gdk.Drag, reason: Gdk.DragCancelReason) => boolean,
            ): number;
            connect_after(
                signal: 'drag-cancel',
                callback: (_source: this, drag: Gdk.Drag, reason: Gdk.DragCancelReason) => boolean,
            ): number;
            emit(signal: 'drag-cancel', drag: Gdk.Drag, reason: Gdk.DragCancelReason): void;
            connect(
                signal: 'drag-end',
                callback: (_source: this, drag: Gdk.Drag, delete_data: boolean) => void,
            ): number;
            connect_after(
                signal: 'drag-end',
                callback: (_source: this, drag: Gdk.Drag, delete_data: boolean) => void,
            ): number;
            emit(signal: 'drag-end', drag: Gdk.Drag, delete_data: boolean): void;
            connect(
                signal: 'prepare',
                callback: (_source: this, x: number, y: number) => Gdk.ContentProvider | null,
            ): number;
            connect_after(
                signal: 'prepare',
                callback: (_source: this, x: number, y: number) => Gdk.ContentProvider | null,
            ): number;
            emit(signal: 'prepare', x: number, y: number): void;

            // Methods

            /**
             * Cancels a currently ongoing drag operation.
             */
            drag_cancel(): void;
            /**
             * Gets the actions that are currently set on the `GtkDragSource`.
             * @returns the actions set on @source
             */
            get_actions(): Gdk.DragAction;
            /**
             * Gets the current content provider of a `GtkDragSource`.
             * @returns the `GdkContentProvider` of @source
             */
            get_content(): Gdk.ContentProvider | null;
            /**
             * Returns the underlying `GdkDrag` object for an ongoing drag.
             * @returns the `GdkDrag` of the current   drag operation
             */
            get_drag(): Gdk.Drag | null;
            /**
             * Sets the actions on the `GtkDragSource`.
             *
             * During a DND operation, the actions are offered to potential
             * drop targets. If `actions` include %GDK_ACTION_MOVE, you need
             * to listen to the [signal`Gtk`.DragSource::drag-end] signal and
             * handle `delete_data` being %TRUE.
             *
             * This function can be called before a drag is started,
             * or in a handler for the [signal`Gtk`.DragSource::prepare] signal.
             * @param actions the actions to offer
             */
            set_actions(actions: Gdk.DragAction | null): void;
            /**
             * Sets a content provider on a `GtkDragSource`.
             *
             * When the data is requested in the cause of a DND operation,
             * it will be obtained from the content provider.
             *
             * This function can be called before a drag is started,
             * or in a handler for the [signal`Gtk`.DragSource::prepare] signal.
             *
             * You may consider setting the content provider back to
             * %NULL in a [signal`Gtk`.DragSource::drag-end] signal handler.
             * @param content a `GdkContentProvider`
             */
            set_content(content?: Gdk.ContentProvider | null): void;
            /**
             * Sets a paintable to use as icon during DND operations.
             *
             * The hotspot coordinates determine the point on the icon
             * that gets aligned with the hotspot of the cursor.
             *
             * If `paintable` is %NULL, a default icon is used.
             *
             * This function can be called before a drag is started, or in
             * a [signal`Gtk`.DragSource::prepare] or
             * [signal`Gtk`.DragSource::drag-begin] signal handler.
             * @param paintable the `GdkPaintable` to use as icon
             * @param hot_x the hotspot X coordinate on the icon
             * @param hot_y the hotspot Y coordinate on the icon
             */
            set_icon(paintable: Gdk.Paintable | null, hot_x: number, hot_y: number): void;
        }

        namespace DrawingArea {
            // Signal callback interfaces

            interface Resize {
                (width: number, height: number): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                content_height: number;
                contentHeight: number;
                content_width: number;
                contentWidth: number;
            }
        }

        /**
         * `GtkDrawingArea` is a widget that allows drawing with cairo.
         *
         * ![An example GtkDrawingArea](drawingarea.png)
         *
         * It’s essentially a blank widget; you can draw on it. After
         * creating a drawing area, the application may want to connect to:
         *
         * - The [signal`Gtk`.Widget::realize] signal to take any necessary actions
         *   when the widget is instantiated on a particular display.
         *   (Create GDK resources in response to this signal.)
         *
         * - The [signal`Gtk`.DrawingArea::resize] signal to take any necessary
         *   actions when the widget changes size.
         *
         * - Call [method`Gtk`.DrawingArea.set_draw_func] to handle redrawing the
         *   contents of the widget.
         *
         * The following code portion demonstrates using a drawing
         * area to display a circle in the normal widget foreground
         * color.
         *
         * ## Simple GtkDrawingArea usage
         *
         * ```c
         * static void
         * draw_function (GtkDrawingArea *area,
         *                cairo_t        *cr,
         *                int             width,
         *                int             height,
         *                gpointer        data)
         * {
         *   GdkRGBA color;
         *
         *   cairo_arc (cr,
         *              width / 2.0, height / 2.0,
         *              MIN (width, height) / 2.0,
         *              0, 2 * G_PI);
         *
         *   gtk_widget_get_color (GTK_WIDGET (area),
         *                         &color);
         *   gdk_cairo_set_source_rgba (cr, &color);
         *
         *   cairo_fill (cr);
         * }
         *
         * int
         * main (int argc, char **argv)
         * {
         *   gtk_init ();
         *
         *   GtkWidget *area = gtk_drawing_area_new ();
         *   gtk_drawing_area_set_content_width (GTK_DRAWING_AREA (area), 100);
         *   gtk_drawing_area_set_content_height (GTK_DRAWING_AREA (area), 100);
         *   gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (area),
         *                                   draw_function,
         *                                   NULL, NULL);
         *   return 0;
         * }
         * ```
         *
         * The draw function is normally called when a drawing area first comes
         * onscreen, or when it’s covered by another window and then uncovered.
         * You can also force a redraw by adding to the “damage region” of the
         * drawing area’s window using [method`Gtk`.Widget.queue_draw].
         * This will cause the drawing area to call the draw function again.
         *
         * The available routines for drawing are documented in the
         * [Cairo documentation](https://www.cairographics.org/manual/); GDK
         * offers additional API to integrate with Cairo, like [func`Gdk`.cairo_set_source_rgba]
         * or [func`Gdk`.cairo_set_source_pixbuf].
         *
         * To receive mouse events on a drawing area, you will need to use
         * event controllers. To receive keyboard events, you will need to set
         * the “can-focus” property on the drawing area, and you should probably
         * draw some user-visible indication that the drawing area is focused.
         *
         * If you need more complex control over your widget, you should consider
         * creating your own `GtkWidget` subclass.
         */
        class DrawingArea extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<DrawingArea>;

            // Properties

            /**
             * The content height.
             */
            get content_height(): number;
            set content_height(val: number);
            /**
             * The content height.
             */
            get contentHeight(): number;
            set contentHeight(val: number);
            /**
             * The content width.
             */
            get content_width(): number;
            set content_width(val: number);
            /**
             * The content width.
             */
            get contentWidth(): number;
            set contentWidth(val: number);

            // Fields

            widget: Widget;

            // Constructors

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

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

            static ['new'](): DrawingArea;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'resize', callback: (_source: this, width: number, height: number) => void): number;
            connect_after(signal: 'resize', callback: (_source: this, width: number, height: number) => void): number;
            emit(signal: 'resize', width: number, height: number): void;

            // Virtual methods

            vfunc_resize(width: number, height: number): void;

            // Methods

            /**
             * Retrieves the content height of the `GtkDrawingArea`.
             * @returns The height requested for content of the drawing area
             */
            get_content_height(): number;
            /**
             * Retrieves the content width of the `GtkDrawingArea`.
             * @returns The width requested for content of the drawing area
             */
            get_content_width(): number;
            /**
             * Sets the desired height of the contents of the drawing area.
             *
             * Note that because widgets may be allocated larger sizes than they
             * requested, it is possible that the actual height passed to your draw
             * function is larger than the height set here. You can use
             * [method`Gtk`.Widget.set_valign] to avoid that.
             *
             * If the height is set to 0 (the default), the drawing area may disappear.
             * @param height the height of contents
             */
            set_content_height(height: number): void;
            /**
             * Sets the desired width of the contents of the drawing area.
             *
             * Note that because widgets may be allocated larger sizes than they
             * requested, it is possible that the actual width passed to your draw
             * function is larger than the width set here. You can use
             * [method`Gtk`.Widget.set_halign] to avoid that.
             *
             * If the width is set to 0 (the default), the drawing area may disappear.
             * @param width the width of contents
             */
            set_content_width(width: number): void;
            /**
             * Setting a draw function is the main thing you want to do when using
             * a drawing area.
             *
             * The draw function is called whenever GTK needs to draw the contents
             * of the drawing area to the screen.
             *
             * The draw function will be called during the drawing stage of GTK.
             * In the drawing stage it is not allowed to change properties of any
             * GTK widgets or call any functions that would cause any properties
             * to be changed. You should restrict yourself exclusively to drawing
             * your contents in the draw function.
             *
             * If what you are drawing does change, call [method`Gtk`.Widget.queue_draw]
             * on the drawing area. This will cause a redraw and will call `draw_func` again.
             * @param draw_func callback   that lets you draw the drawing area's contents
             */
            set_draw_func(draw_func?: DrawingAreaDrawFunc | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace DropControllerMotion {
            // Signal callback interfaces

            interface Enter {
                (x: number, y: number): void;
            }

            interface Leave {
                (): void;
            }

            interface Motion {
                (x: number, y: number): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends EventController.ConstructorProps {
                contains_pointer: boolean;
                containsPointer: boolean;
                drop: Gdk.Drop;
                is_pointer: boolean;
                isPointer: boolean;
            }
        }

        /**
         * `GtkDropControllerMotion` is an event controller tracking
         * the pointer during Drag-and-Drop operations.
         *
         * It is modeled after [class`Gtk`.EventControllerMotion] so if you
         * have used that, this should feel really familiar.
         *
         * This controller is not able to accept drops, use [class`Gtk`.DropTarget]
         * for that purpose.
         */
        class DropControllerMotion extends EventController {
            static $gtype: GObject.GType<DropControllerMotion>;

            // Properties

            /**
             * Whether the pointer of a Drag-and-Drop operation is in
             * the controller's widget or a descendant.
             *
             * See also [property`Gtk`.DropControllerMotion:is-pointer].
             *
             * When handling crossing events, this property is updated
             * before [signal`Gtk`.DropControllerMotion::enter], but after
             * [signal`Gtk`.DropControllerMotion::leave] is emitted.
             */
            get contains_pointer(): boolean;
            /**
             * Whether the pointer of a Drag-and-Drop operation is in
             * the controller's widget or a descendant.
             *
             * See also [property`Gtk`.DropControllerMotion:is-pointer].
             *
             * When handling crossing events, this property is updated
             * before [signal`Gtk`.DropControllerMotion::enter], but after
             * [signal`Gtk`.DropControllerMotion::leave] is emitted.
             */
            get containsPointer(): boolean;
            /**
             * The ongoing drop operation over the controller's widget or
             * its descendant.
             *
             * If no drop operation is going on, this property returns %NULL.
             *
             * The event controller should not modify the `drop,` but it might
             * want to query its properties.
             *
             * When handling crossing events, this property is updated
             * before [signal`Gtk`.DropControllerMotion::enter], but after
             * [signal`Gtk`.DropControllerMotion::leave] is emitted.
             */
            get drop(): Gdk.Drop;
            /**
             * Whether the pointer is in the controllers widget itself,
             * as opposed to in a descendent widget.
             *
             * See also [property`Gtk`.DropControllerMotion:contains-pointer].
             *
             * When handling crossing events, this property is updated
             * before [signal`Gtk`.DropControllerMotion::enter], but after
             * [signal`Gtk`.DropControllerMotion::leave] is emitted.
             */
            get is_pointer(): boolean;
            /**
             * Whether the pointer is in the controllers widget itself,
             * as opposed to in a descendent widget.
             *
             * See also [property`Gtk`.DropControllerMotion:contains-pointer].
             *
             * When handling crossing events, this property is updated
             * before [signal`Gtk`.DropControllerMotion::enter], but after
             * [signal`Gtk`.DropControllerMotion::leave] is emitted.
             */
            get isPointer(): boolean;

            // Constructors

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

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

            static ['new'](): DropControllerMotion;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'enter', callback: (_source: this, x: number, y: number) => void): number;
            connect_after(signal: 'enter', callback: (_source: this, x: number, y: number) => void): number;
            emit(signal: 'enter', x: number, y: number): void;
            connect(signal: 'leave', callback: (_source: this) => void): number;
            connect_after(signal: 'leave', callback: (_source: this) => void): number;
            emit(signal: 'leave'): void;
            connect(signal: 'motion', callback: (_source: this, x: number, y: number) => void): number;
            connect_after(signal: 'motion', callback: (_source: this, x: number, y: number) => void): number;
            emit(signal: 'motion', x: number, y: number): void;

            // Methods

            /**
             * Returns the `GdkDrop` of a current Drag-and-Drop operation
             * over the widget of `self`.
             * @returns The `GdkDrop` currently   happening within @self
             */
            get_drop(): Gdk.Drop | null;
        }

        namespace DropDown {
            // Signal callback interfaces

            interface Activate {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                enable_search: boolean;
                enableSearch: boolean;
                expression: Expression;
                factory: ListItemFactory;
                header_factory: ListItemFactory;
                headerFactory: ListItemFactory;
                list_factory: ListItemFactory;
                listFactory: ListItemFactory;
                model: Gio.ListModel;
                search_match_mode: StringFilterMatchMode;
                searchMatchMode: StringFilterMatchMode;
                selected: number;
                selected_item: GObject.Object;
                selectedItem: GObject.Object;
                show_arrow: boolean;
                showArrow: boolean;
            }
        }

        /**
         * `GtkDropDown` is a widget that allows the user to choose an item
         * from a list of options.
         *
         * ![An example GtkDropDown](drop-down.png)
         *
         * The `GtkDropDown` displays the [selected][property`Gtk`.DropDown:selected]
         * choice.
         *
         * The options are given to `GtkDropDown` in the form of `GListModel`
         * and how the individual options are represented is determined by
         * a [class`Gtk`.ListItemFactory]. The default factory displays simple strings,
         * and adds a checkmark to the selected item in the popup.
         *
         * To set your own factory, use [method`Gtk`.DropDown.set_factory]. It is
         * possible to use a separate factory for the items in the popup, with
         * [method`Gtk`.DropDown.set_list_factory].
         *
         * `GtkDropDown` knows how to obtain strings from the items in a
         * [class`Gtk`.StringList]; for other models, you have to provide an expression
         * to find the strings via [method`Gtk`.DropDown.set_expression].
         *
         * `GtkDropDown` can optionally allow search in the popup, which is
         * useful if the list of options is long. To enable the search entry,
         * use [method`Gtk`.DropDown.set_enable_search].
         *
         * Here is a UI definition example for `GtkDropDown` with a simple model:
         *
         * ```xml
         * <object class="GtkDropDown">
         *   <property name="model">
         *     <object class="GtkStringList">
         *       <items>
         *         <item translatable="yes">Factory</item>
         *         <item translatable="yes">Home</item>
         *         <item translatable="yes">Subway</item>
         *       </items>
         *     </object>
         *   </property>
         * </object>
         * ```
         *
         * If a `GtkDropDown` is created in this manner, or with
         * [ctor`Gtk`.DropDown.new_from_strings], for instance, the object returned from
         * [method`Gtk`.DropDown.get_selected_item] will be a [class`Gtk`.StringObject].
         *
         * To learn more about the list widget framework, see the
         * [overview](section-list-widget.html).
         *
         * ## CSS nodes
         *
         * `GtkDropDown` has a single CSS node with name dropdown,
         * with the button and popover nodes as children.
         *
         * ## Accessibility
         *
         * `GtkDropDown` uses the %GTK_ACCESSIBLE_ROLE_COMBO_BOX role.
         */
        class DropDown extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<DropDown>;

            // Properties

            /**
             * Whether to show a search entry in the popup.
             *
             * Note that search requires [property`Gtk`.DropDown:expression]
             * to be set.
             */
            get enable_search(): boolean;
            set enable_search(val: boolean);
            /**
             * Whether to show a search entry in the popup.
             *
             * Note that search requires [property`Gtk`.DropDown:expression]
             * to be set.
             */
            get enableSearch(): boolean;
            set enableSearch(val: boolean);
            /**
             * An expression to evaluate to obtain strings to match against the search
             * term.
             *
             * See [property`Gtk`.DropDown:enable-search] for how to enable search.
             * If [property`Gtk`.DropDown:factory] is not set, the expression is also
             * used to bind strings to labels produced by a default factory.
             */
            get expression(): Expression;
            set expression(val: Expression);
            /**
             * Factory for populating list items.
             */
            get factory(): ListItemFactory;
            set factory(val: ListItemFactory);
            /**
             * The factory for creating header widgets for the popup.
             */
            get header_factory(): ListItemFactory;
            set header_factory(val: ListItemFactory);
            /**
             * The factory for creating header widgets for the popup.
             */
            get headerFactory(): ListItemFactory;
            set headerFactory(val: ListItemFactory);
            /**
             * The factory for populating list items in the popup.
             *
             * If this is not set, [property`Gtk`.DropDown:factory] is used.
             */
            get list_factory(): ListItemFactory;
            set list_factory(val: ListItemFactory);
            /**
             * The factory for populating list items in the popup.
             *
             * If this is not set, [property`Gtk`.DropDown:factory] is used.
             */
            get listFactory(): ListItemFactory;
            set listFactory(val: ListItemFactory);
            /**
             * Model for the displayed items.
             */
            get model(): Gio.ListModel;
            set model(val: Gio.ListModel);
            /**
             * The match mode for the search filter.
             */
            get search_match_mode(): StringFilterMatchMode;
            set search_match_mode(val: StringFilterMatchMode);
            /**
             * The match mode for the search filter.
             */
            get searchMatchMode(): StringFilterMatchMode;
            set searchMatchMode(val: StringFilterMatchMode);
            /**
             * The position of the selected item.
             *
             * If no item is selected, the property has the value
             * %GTK_INVALID_LIST_POSITION.
             */
            get selected(): number;
            set selected(val: number);
            /**
             * The selected item.
             */
            get selected_item(): GObject.Object;
            /**
             * The selected item.
             */
            get selectedItem(): GObject.Object;
            /**
             * Whether to show an arrow within the GtkDropDown widget.
             */
            get show_arrow(): boolean;
            set show_arrow(val: boolean);
            /**
             * Whether to show an arrow within the GtkDropDown widget.
             */
            get showArrow(): boolean;
            set showArrow(val: boolean);

            // Constructors

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

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

            static ['new'](model?: Gio.ListModel | null, expression?: Expression | null): DropDown;

            static new_from_strings(strings: string[]): DropDown;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate', callback: (_source: this) => void): number;
            connect_after(signal: 'activate', callback: (_source: this) => void): number;
            emit(signal: 'activate'): void;

            // Methods

            /**
             * Returns whether search is enabled.
             * @returns %TRUE if the popup includes a search entry
             */
            get_enable_search(): boolean;
            /**
             * Gets the expression set that is used to obtain strings from items.
             *
             * See [method`Gtk`.DropDown.set_expression].
             * @returns a `GtkExpression`
             */
            get_expression(): Expression | null;
            /**
             * Gets the factory that's currently used to populate list items.
             *
             * The factory returned by this function is always used for the
             * item in the button. It is also used for items in the popup
             * if [property`Gtk`.DropDown:list-factory] is not set.
             * @returns The factory in use
             */
            get_factory(): ListItemFactory | null;
            /**
             * Gets the factory that's currently used to create header widgets for the popup.
             * @returns The factory in use
             */
            get_header_factory(): ListItemFactory | null;
            /**
             * Gets the factory that's currently used to populate list items in the popup.
             * @returns The factory in use
             */
            get_list_factory(): ListItemFactory | null;
            /**
             * Gets the model that provides the displayed items.
             * @returns The model in use
             */
            get_model(): Gio.ListModel | null;
            /**
             * Returns the match mode that the search filter is using.
             * @returns the match mode of the search filter
             */
            get_search_match_mode(): StringFilterMatchMode;
            /**
             * Gets the position of the selected item.
             * @returns the position of the selected item, or %GTK_INVALID_LIST_POSITION   if not item is selected
             */
            get_selected(): number;
            /**
             * Gets the selected item. If no item is selected, %NULL is returned.
             * @returns The selected item
             */
            get_selected_item<T = GObject.Object>(): T;
            /**
             * Returns whether to show an arrow within the widget.
             * @returns %TRUE if an arrow will be shown.
             */
            get_show_arrow(): boolean;
            /**
             * Sets whether a search entry will be shown in the popup that
             * allows to search for items in the list.
             *
             * Note that [property`Gtk`.DropDown:expression] must be set for
             * search to work.
             * @param enable_search whether to enable search
             */
            set_enable_search(enable_search: boolean): void;
            /**
             * Sets the expression that gets evaluated to obtain strings from items.
             *
             * This is used for search in the popup. The expression must have
             * a value type of %G_TYPE_STRING.
             * @param expression a `GtkExpression`
             */
            set_expression(expression?: Expression | null): void;
            /**
             * Sets the `GtkListItemFactory` to use for populating list items.
             * @param factory the factory to use
             */
            set_factory(factory?: ListItemFactory | null): void;
            /**
             * Sets the `GtkListItemFactory` to use for creating header widgets for the popup.
             * @param factory the factory to use
             */
            set_header_factory(factory?: ListItemFactory | null): void;
            /**
             * Sets the `GtkListItemFactory` to use for populating list items in the popup.
             * @param factory the factory to use
             */
            set_list_factory(factory?: ListItemFactory | null): void;
            /**
             * Sets the `GListModel` to use.
             * @param model the model to use
             */
            set_model(model?: Gio.ListModel | null): void;
            /**
             * Sets the match mode for the search filter.
             * @param search_match_mode the new match mode
             */
            set_search_match_mode(search_match_mode: StringFilterMatchMode | null): void;
            /**
             * Selects the item at the given position.
             * @param position the position of the item to select, or %GTK_INVALID_LIST_POSITION
             */
            set_selected(position: number): void;
            /**
             * Sets whether an arrow will be displayed within the widget.
             * @param show_arrow whether to show an arrow within the widget
             */
            set_show_arrow(show_arrow: boolean): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace DropTarget {
            // Signal callback interfaces

            interface Accept {
                (drop: Gdk.Drop): boolean;
            }

            interface Drop {
                (value: GObject.Value | any, x: number, y: number): boolean;
            }

            interface Enter {
                (x: number, y: number): Gdk.DragAction;
            }

            interface Leave {
                (): void;
            }

            interface Motion {
                (x: number, y: number): Gdk.DragAction;
            }

            // Constructor properties interface

            interface ConstructorProps extends EventController.ConstructorProps {
                actions: Gdk.DragAction;
                current_drop: Gdk.Drop;
                currentDrop: Gdk.Drop;
                drop: Gdk.Drop;
                formats: Gdk.ContentFormats;
                preload: boolean;
                value: GObject.Value;
            }
        }

        /**
         * `GtkDropTarget` is an event controller to receive Drag-and-Drop operations.
         *
         * The most basic way to use a `GtkDropTarget` to receive drops on a
         * widget is to create it via [ctor`Gtk`.DropTarget.new], passing in the
         * `GType` of the data you want to receive and connect to the
         * [signal`Gtk`.DropTarget::drop] signal to receive the data:
         *
         * ```c
         * static gboolean
         * on_drop (GtkDropTarget *target,
         *          const GValue  *value,
         *          double         x,
         *          double         y,
         *          gpointer       data)
         * {
         *   MyWidget *self = data;
         *
         *   // Call the appropriate setter depending on the type of data
         *   // that we received
         *   if (G_VALUE_HOLDS (value, G_TYPE_FILE))
         *     my_widget_set_file (self, g_value_get_object (value));
         *   else if (G_VALUE_HOLDS (value, GDK_TYPE_PIXBUF))
         *     my_widget_set_pixbuf (self, g_value_get_object (value));
         *   else
         *     return FALSE;
         *
         *   return TRUE;
         * }
         *
         * static void
         * my_widget_init (MyWidget *self)
         * {
         *   GtkDropTarget *target =
         *     gtk_drop_target_new (G_TYPE_INVALID, GDK_ACTION_COPY);
         *
         *   // This widget accepts two types of drop types: GFile objects
         *   // and GdkPixbuf objects
         *   gtk_drop_target_set_gtypes (target, (GType [2]) {
         *     G_TYPE_FILE,
         *     GDK_TYPE_PIXBUF,
         *   }, 2);
         *
         *   g_signal_connect (target, "drop", G_CALLBACK (on_drop), self);
         *   gtk_widget_add_controller (GTK_WIDGET (self), GTK_EVENT_CONTROLLER (target));
         * }
         * ```
         *
         * `GtkDropTarget` supports more options, such as:
         *
         *  * rejecting potential drops via the [signal`Gtk`.DropTarget::accept] signal
         *    and the [method`Gtk`.DropTarget.reject] function to let other drop
         *    targets handle the drop
         *  * tracking an ongoing drag operation before the drop via the
         *    [signal`Gtk`.DropTarget::enter], [signal`Gtk`.DropTarget::motion] and
         *    [signal`Gtk`.DropTarget::leave] signals
         *  * configuring how to receive data by setting the
         *    [property`Gtk`.DropTarget:preload] property and listening for its
         *    availability via the [property`Gtk`.DropTarget:value] property
         *
         * However, `GtkDropTarget` is ultimately modeled in a synchronous way
         * and only supports data transferred via `GType`. If you want full control
         * over an ongoing drop, the [class`Gtk`.DropTargetAsync] object gives you
         * this ability.
         *
         * While a pointer is dragged over the drop target's widget and the drop
         * has not been rejected, that widget will receive the
         * %GTK_STATE_FLAG_DROP_ACTIVE state, which can be used to style the widget.
         *
         * If you are not interested in receiving the drop, but just want to update
         * UI state during a Drag-and-Drop operation (e.g. switching tabs), you can
         * use [class`Gtk`.DropControllerMotion].
         */
        class DropTarget extends EventController {
            static $gtype: GObject.GType<DropTarget>;

            // Properties

            /**
             * The `GdkDragActions` that this drop target supports.
             */
            get actions(): Gdk.DragAction;
            set actions(val: Gdk.DragAction);
            /**
             * The `GdkDrop` that is currently being performed.
             */
            get current_drop(): Gdk.Drop;
            /**
             * The `GdkDrop` that is currently being performed.
             */
            get currentDrop(): Gdk.Drop;
            /**
             * The `GdkDrop` that is currently being performed.
             */
            get drop(): Gdk.Drop;
            /**
             * The `GdkContentFormats` that determine the supported data formats.
             */
            get formats(): Gdk.ContentFormats;
            /**
             * Whether the drop data should be preloaded when the pointer is only
             * hovering over the widget but has not been released.
             *
             * Setting this property allows finer grained reaction to an ongoing
             * drop at the cost of loading more data.
             *
             * The default value for this property is %FALSE to avoid downloading
             * huge amounts of data by accident.
             *
             * For example, if somebody drags a full document of gigabytes of text
             * from a text editor across a widget with a preloading drop target,
             * this data will be downloaded, even if the data is ultimately dropped
             * elsewhere.
             *
             * For a lot of data formats, the amount of data is very small (like
             * %GDK_TYPE_RGBA), so enabling this property does not hurt at all.
             * And for local-only Drag-and-Drop operations, no data transfer is done,
             * so enabling it there is free.
             */
            get preload(): boolean;
            set preload(val: boolean);
            /**
             * The value for this drop operation.
             *
             * This is %NULL if the data has not been loaded yet or no drop
             * operation is going on.
             *
             * Data may be available before the [signal`Gtk`.DropTarget::drop]
             * signal gets emitted - for example when the [property`Gtk`.DropTarget:preload]
             * property is set. You can use the ::notify signal to be notified
             * of available data.
             */
            get value(): GObject.Value;

            // Constructors

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

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

            static ['new'](type: GObject.GType, actions: Gdk.DragAction): DropTarget;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'accept', callback: (_source: this, drop: Gdk.Drop) => boolean): number;
            connect_after(signal: 'accept', callback: (_source: this, drop: Gdk.Drop) => boolean): number;
            emit(signal: 'accept', drop: Gdk.Drop): void;
            connect(
                signal: 'drop',
                callback: (_source: this, value: GObject.Value, x: number, y: number) => boolean,
            ): number;
            connect_after(
                signal: 'drop',
                callback: (_source: this, value: GObject.Value, x: number, y: number) => boolean,
            ): number;
            emit(signal: 'drop', value: GObject.Value | any, x: number, y: number): void;
            connect(signal: 'enter', callback: (_source: this, x: number, y: number) => Gdk.DragAction): number;
            connect_after(signal: 'enter', callback: (_source: this, x: number, y: number) => Gdk.DragAction): number;
            emit(signal: 'enter', x: number, y: number): void;
            connect(signal: 'leave', callback: (_source: this) => void): number;
            connect_after(signal: 'leave', callback: (_source: this) => void): number;
            emit(signal: 'leave'): void;
            connect(signal: 'motion', callback: (_source: this, x: number, y: number) => Gdk.DragAction): number;
            connect_after(signal: 'motion', callback: (_source: this, x: number, y: number) => Gdk.DragAction): number;
            emit(signal: 'motion', x: number, y: number): void;

            // Methods

            /**
             * Gets the actions that this drop target supports.
             * @returns the actions that this drop target supports
             */
            get_actions(): Gdk.DragAction;
            /**
             * Gets the currently handled drop operation.
             *
             * If no drop operation is going on, %NULL is returned.
             * @returns The current drop
             */
            get_current_drop(): Gdk.Drop | null;
            /**
             * Gets the currently handled drop operation.
             *
             * If no drop operation is going on, %NULL is returned.
             * @returns The current drop
             */
            get_drop(): Gdk.Drop | null;
            /**
             * Gets the data formats that this drop target accepts.
             *
             * If the result is %NULL, all formats are expected to be supported.
             * @returns the supported data formats
             */
            get_formats(): Gdk.ContentFormats | null;
            /**
             * Gets the list of supported `GType`s that can be dropped on the target.
             *
             * If no types have been set, `NULL` will be returned.
             * @returns the `G_TYPE_INVALID`-terminated array of types included in   formats
             */
            get_gtypes(): GObject.GType[] | null;
            /**
             * Gets whether data should be preloaded on hover.
             * @returns %TRUE if drop data should be preloaded
             */
            get_preload(): boolean;
            /**
             * Gets the current drop data, as a `GValue`.
             * @returns The current drop data
             */
            get_value(): GObject.Value | null;
            /**
             * Rejects the ongoing drop operation.
             *
             * If no drop operation is ongoing, i.e when [property`Gtk`.DropTarget:current-drop]
             * is %NULL, this function does nothing.
             *
             * This function should be used when delaying the decision
             * on whether to accept a drag or not until after reading
             * the data.
             */
            reject(): void;
            /**
             * Sets the actions that this drop target supports.
             * @param actions the supported actions
             */
            set_actions(actions: Gdk.DragAction | null): void;
            /**
             * Sets the supported `GType`s for this drop target.
             * @param types all supported `GType`s   that can be dropped on the target
             */
            set_gtypes(types?: GObject.GType[] | null): void;
            /**
             * Sets whether data should be preloaded on hover.
             * @param preload %TRUE to preload drop data
             */
            set_preload(preload: boolean): void;
        }

        namespace DropTargetAsync {
            // Signal callback interfaces

            interface Accept {
                (drop: Gdk.Drop): boolean;
            }

            interface DragEnter {
                (drop: Gdk.Drop, x: number, y: number): Gdk.DragAction;
            }

            interface DragLeave {
                (drop: Gdk.Drop): void;
            }

            interface DragMotion {
                (drop: Gdk.Drop, x: number, y: number): Gdk.DragAction;
            }

            interface Drop {
                (drop: Gdk.Drop, x: number, y: number): boolean;
            }

            // Constructor properties interface

            interface ConstructorProps extends EventController.ConstructorProps {
                actions: Gdk.DragAction;
                formats: Gdk.ContentFormats;
            }
        }

        /**
         * `GtkDropTargetAsync` is an event controller to receive Drag-and-Drop
         * operations, asynchronously.
         *
         * It is the more complete but also more complex method of handling drop
         * operations compared to [class`Gtk`.DropTarget], and you should only use
         * it if `GtkDropTarget` doesn't provide all the features you need.
         *
         * To use a `GtkDropTargetAsync` to receive drops on a widget, you create
         * a `GtkDropTargetAsync` object, configure which data formats and actions
         * you support, connect to its signals, and then attach it to the widget
         * with [method`Gtk`.Widget.add_controller].
         *
         * During a drag operation, the first signal that a `GtkDropTargetAsync`
         * emits is [signal`Gtk`.DropTargetAsync::accept], which is meant to determine
         * whether the target is a possible drop site for the ongoing drop. The
         * default handler for the ::accept signal accepts the drop if it finds
         * a compatible data format and an action that is supported on both sides.
         *
         * If it is, and the widget becomes a target, you will receive a
         * [signal`Gtk`.DropTargetAsync::drag-enter] signal, followed by
         * [signal`Gtk`.DropTargetAsync::drag-motion] signals as the pointer moves,
         * optionally a [signal`Gtk`.DropTargetAsync::drop] signal when a drop happens,
         * and finally a [signal`Gtk`.DropTargetAsync::drag-leave] signal when the
         * pointer moves off the widget.
         *
         * The ::drag-enter and ::drag-motion handler return a `GdkDragAction`
         * to update the status of the ongoing operation. The ::drop handler
         * should decide if it ultimately accepts the drop and if it does, it
         * should initiate the data transfer and finish the operation by calling
         * [method`Gdk`.Drop.finish].
         *
         * Between the ::drag-enter and ::drag-leave signals the widget is a
         * current drop target, and will receive the %GTK_STATE_FLAG_DROP_ACTIVE
         * state, which can be used by themes to style the widget as a drop target.
         */
        class DropTargetAsync extends EventController {
            static $gtype: GObject.GType<DropTargetAsync>;

            // Properties

            /**
             * The `GdkDragActions` that this drop target supports.
             */
            get actions(): Gdk.DragAction;
            set actions(val: Gdk.DragAction);
            /**
             * The `GdkContentFormats` that determines the supported data formats.
             */
            get formats(): Gdk.ContentFormats;
            set formats(val: Gdk.ContentFormats);

            // Constructors

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

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

            static ['new'](formats: Gdk.ContentFormats | null, actions: Gdk.DragAction): DropTargetAsync;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'accept', callback: (_source: this, drop: Gdk.Drop) => boolean): number;
            connect_after(signal: 'accept', callback: (_source: this, drop: Gdk.Drop) => boolean): number;
            emit(signal: 'accept', drop: Gdk.Drop): void;
            connect(
                signal: 'drag-enter',
                callback: (_source: this, drop: Gdk.Drop, x: number, y: number) => Gdk.DragAction,
            ): number;
            connect_after(
                signal: 'drag-enter',
                callback: (_source: this, drop: Gdk.Drop, x: number, y: number) => Gdk.DragAction,
            ): number;
            emit(signal: 'drag-enter', drop: Gdk.Drop, x: number, y: number): void;
            connect(signal: 'drag-leave', callback: (_source: this, drop: Gdk.Drop) => void): number;
            connect_after(signal: 'drag-leave', callback: (_source: this, drop: Gdk.Drop) => void): number;
            emit(signal: 'drag-leave', drop: Gdk.Drop): void;
            connect(
                signal: 'drag-motion',
                callback: (_source: this, drop: Gdk.Drop, x: number, y: number) => Gdk.DragAction,
            ): number;
            connect_after(
                signal: 'drag-motion',
                callback: (_source: this, drop: Gdk.Drop, x: number, y: number) => Gdk.DragAction,
            ): number;
            emit(signal: 'drag-motion', drop: Gdk.Drop, x: number, y: number): void;
            connect(signal: 'drop', callback: (_source: this, drop: Gdk.Drop, x: number, y: number) => boolean): number;
            connect_after(
                signal: 'drop',
                callback: (_source: this, drop: Gdk.Drop, x: number, y: number) => boolean,
            ): number;
            emit(signal: 'drop', drop: Gdk.Drop, x: number, y: number): void;

            // Methods

            /**
             * Gets the actions that this drop target supports.
             * @returns the actions that this drop target supports
             */
            get_actions(): Gdk.DragAction;
            /**
             * Gets the data formats that this drop target accepts.
             *
             * If the result is %NULL, all formats are expected to be supported.
             * @returns the supported data formats
             */
            get_formats(): Gdk.ContentFormats | null;
            /**
             * Sets the `drop` as not accepted on this drag site.
             *
             * This function should be used when delaying the decision
             * on whether to accept a drag or not until after reading
             * the data.
             * @param drop the `GdkDrop` of an ongoing drag operation
             */
            reject_drop(drop: Gdk.Drop): void;
            /**
             * Sets the actions that this drop target supports.
             * @param actions the supported actions
             */
            set_actions(actions: Gdk.DragAction | null): void;
            /**
             * Sets the data formats that this drop target will accept.
             * @param formats the supported data formats or %NULL for any format
             */
            set_formats(formats?: Gdk.ContentFormats | null): void;
        }

        namespace EditableLabel {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Editable.ConstructorProps {
                editing: boolean;
            }
        }

        /**
         * A `GtkEditableLabel` is a label that allows users to
         * edit the text by switching to an “edit mode”.
         *
         * ![An example GtkEditableLabel](editable-label.png)
         *
         * `GtkEditableLabel` does not have API of its own, but it
         * implements the [iface`Gtk`.Editable] interface.
         *
         * The default bindings for activating the edit mode is
         * to click or press the Enter key. The default bindings
         * for leaving the edit mode are the Enter key (to save
         * the results) or the Escape key (to cancel the editing).
         *
         * # Shortcuts and Gestures
         *
         * `GtkEditableLabel` supports the following keyboard shortcuts:
         *
         * - <kbd>Enter</kbd> starts editing.
         * - <kbd>Escape</kbd> stops editing.
         *
         * # Actions
         *
         * `GtkEditableLabel` defines a set of built-in actions:
         *
         * - `editing.starts` switches the widget into editing mode.
         * - `editing.stop` switches the widget out of editing mode.
         *
         * # CSS nodes
         *
         * ```
         * editablelabel[.editing]
         * ╰── stack
         *     ├── label
         *     ╰── text
         * ```
         *
         * `GtkEditableLabel` has a main node with the name editablelabel.
         * When the entry is in editing mode, it gets the .editing style
         * class.
         *
         * For all the subnodes added to the text node in various situations,
         * see [class`Gtk`.Text].
         */
        class EditableLabel extends Widget implements Accessible, Buildable, ConstraintTarget, Editable {
            static $gtype: GObject.GType<EditableLabel>;

            // Properties

            /**
             * This property is %TRUE while the widget is in edit mode.
             */
            get editing(): boolean;
            set editing(val: boolean);

            // Constructors

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

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

            static ['new'](str: string): EditableLabel;

            // Methods

            /**
             * Returns whether the label is currently in “editing mode”.
             * @returns %TRUE if @self is currently in editing mode
             */
            get_editing(): boolean;
            /**
             * Switches the label into “editing mode”.
             */
            start_editing(): void;
            /**
             * Switches the label out of “editing mode”.
             *
             * If `commit` is %TRUE, the resulting text is kept as the
             * [property`Gtk`.Editable:text] property value, otherwise the
             * resulting text is discarded and the label will keep its
             * previous [property`Gtk`.Editable:text] property value.
             * @param commit whether to set the edited text on the label
             */
            stop_editing(commit: boolean): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The current position of the insertion cursor in chars.
             */
            get cursor_position(): number;
            /**
             * The current position of the insertion cursor in chars.
             */
            get cursorPosition(): number;
            /**
             * Whether the entry contents can be edited.
             */
            get editable(): boolean;
            set editable(val: boolean);
            /**
             * If undo/redo should be enabled for the editable.
             */
            get enable_undo(): boolean;
            set enable_undo(val: boolean);
            /**
             * If undo/redo should be enabled for the editable.
             */
            get enableUndo(): boolean;
            set enableUndo(val: boolean);
            /**
             * The desired maximum width of the entry, in characters.
             */
            get max_width_chars(): number;
            set max_width_chars(val: number);
            /**
             * The desired maximum width of the entry, in characters.
             */
            get maxWidthChars(): number;
            set maxWidthChars(val: number);
            /**
             * The position of the opposite end of the selection from the cursor in chars.
             */
            get selection_bound(): number;
            /**
             * The position of the opposite end of the selection from the cursor in chars.
             */
            get selectionBound(): number;
            /**
             * The contents of the entry.
             */
            get text(): string;
            set text(val: string);
            /**
             * Number of characters to leave space for in the entry.
             */
            get width_chars(): number;
            set width_chars(val: number);
            /**
             * Number of characters to leave space for in the entry.
             */
            get widthChars(): number;
            set widthChars(val: number);
            /**
             * The horizontal alignment, from 0 (left) to 1 (right).
             *
             * Reversed for RTL layouts.
             */
            get xalign(): number;
            set xalign(val: number);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Retrieves the accessible platform state from the editable delegate.
             *
             * This is an helper function to retrieve the accessible state for
             * `GtkEditable` interface implementations using a delegate pattern.
             *
             * You should call this function in your editable widget implementation
             * of the [vfunc`Gtk`.Accessible.get_platform_state] virtual function, for
             * instance:
             *
             * ```c
             * static void
             * accessible_interface_init (GtkAccessibleInterface *iface)
             * {
             *   iface->get_platform_state = your_editable_get_accessible_platform_state;
             * }
             *
             * static gboolean
             * your_editable_get_accessible_platform_state (GtkAccessible *accessible,
             *                                              GtkAccessiblePlatformState state)
             * {
             *   return gtk_editable_delegate_get_accessible_platform_state (GTK_EDITABLE (accessible), state);
             * }
             * ```
             *
             * Note that the widget which is the delegate *must* be a direct child of
             * this widget, otherwise your implementation of [vfunc`Gtk`.Accessible.get_platform_state]
             * might not even be called, as the platform change will originate from
             * the parent of the delegate, and, as a result, will not work properly.
             *
             * So, if you can't ensure the direct child condition, you should give the
             * delegate the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role, or you can
             * change your tree to allow this function to work.
             * @param state what kind of accessible state to retrieve
             * @returns the accessible platform state of the delegate
             */
            delegate_get_accessible_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Deletes the currently selected text of the editable.
             *
             * This call doesn’t do anything if there is no selected text.
             */
            delete_selection(): void;
            /**
             * Deletes a sequence of characters.
             *
             * The characters that are deleted are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters deleted are those from `start_pos` to
             * the end of the text.
             *
             * Note that the positions are specified in characters, not bytes.
             * @param start_pos start position
             * @param end_pos end position
             */
            delete_text(start_pos: number, end_pos: number): void;
            /**
             * Undoes the setup done by [method`Gtk`.Editable.init_delegate].
             *
             * This is a helper function that should be called from dispose,
             * before removing the delegate object.
             */
            finish_delegate(): void;
            /**
             * Gets the alignment of the editable.
             * @returns the alignment
             */
            get_alignment(): number;
            /**
             * Retrieves a sequence of characters.
             *
             * The characters that are retrieved are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is negative,
             * then the characters retrieved are those characters from `start_pos` to
             * the end of the text.
             *
             * Note that positions are specified in characters, not bytes.
             * @param start_pos start of text
             * @param end_pos end of text
             * @returns a pointer to the contents of the widget as a   string. This string is allocated by the `GtkEditable` implementation   and should be freed by the caller.
             */
            get_chars(start_pos: number, end_pos: number): string;
            /**
             * Gets the `GtkEditable` that `editable` is delegating its
             * implementation to.
             *
             * Typically, the delegate is a [class`Gtk`.Text] widget.
             * @returns the delegate `GtkEditable`
             */
            get_delegate(): Editable | null;
            /**
             * Retrieves whether `editable` is editable.
             * @returns %TRUE if @editable is editable.
             */
            get_editable(): boolean;
            /**
             * Gets if undo/redo actions are enabled for `editable`
             * @returns %TRUE if undo is enabled
             */
            get_enable_undo(): boolean;
            /**
             * Retrieves the desired maximum width of `editable,` in characters.
             * @returns the maximum width of the entry, in characters
             */
            get_max_width_chars(): number;
            /**
             * Retrieves the current position of the cursor relative
             * to the start of the content of the editable.
             *
             * Note that this position is in characters, not in bytes.
             * @returns the cursor position
             */
            get_position(): number;
            /**
             * Retrieves the selection bound of the editable.
             *
             * `start_pos` will be filled with the start of the selection and
             * `end_pos` with end. If no text was selected both will be identical
             * and %FALSE will be returned.
             *
             * Note that positions are specified in characters, not bytes.
             * @returns %TRUE if there is a non-empty selection, %FALSE otherwise
             */
            get_selection_bounds(): [boolean, number, number];
            /**
             * Retrieves the contents of `editable`.
             *
             * The returned string is owned by GTK and must not be modified or freed.
             * @returns a pointer to the contents of the editable
             */
            get_text(): string;
            /**
             * Gets the number of characters of space reserved
             * for the contents of the editable.
             * @returns number of chars to request space for, or negative if unset
             */
            get_width_chars(): number;
            /**
             * Sets up a delegate for `GtkEditable`.
             *
             * This is assuming that the get_delegate vfunc in the `GtkEditable`
             * interface has been set up for the `editable'`s type.
             *
             * This is a helper function that should be called in instance init,
             * after creating the delegate object.
             */
            init_delegate(): void;
            /**
             * Inserts `length` bytes of `text` into the contents of the
             * widget, at position `position`.
             *
             * Note that the position is in characters, not in bytes.
             * The function updates `position` to point after the newly
             * inserted text.
             * @param text the text to insert
             * @param length the length of the text in bytes, or -1
             * @param position location of the position text will be inserted at
             */
            insert_text(text: string, length: number, position: number): number;
            /**
             * Selects a region of text.
             *
             * The characters that are selected are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters selected are those characters from
             * `start_pos` to  the end of the text.
             *
             * Note that positions are specified in characters, not bytes.
             * @param start_pos start of region
             * @param end_pos end of region
             */
            select_region(start_pos: number, end_pos: number): void;
            /**
             * Sets the alignment for the contents of the editable.
             *
             * This controls the horizontal positioning of the contents when
             * the displayed text is shorter than the width of the editable.
             * @param xalign The horizontal alignment, from 0 (left) to 1 (right).   Reversed for RTL layouts
             */
            set_alignment(xalign: number): void;
            /**
             * Determines if the user can edit the text in the editable widget.
             * @param is_editable %TRUE if the user is allowed to edit the text   in the widget
             */
            set_editable(is_editable: boolean): void;
            /**
             * If enabled, changes to `editable` will be saved for undo/redo
             * actions.
             *
             * This results in an additional copy of text changes and are not
             * stored in secure memory. As such, undo is forcefully disabled
             * when [property`Gtk`.Text:visibility] is set to %FALSE.
             * @param enable_undo if undo/redo should be enabled
             */
            set_enable_undo(enable_undo: boolean): void;
            /**
             * Sets the desired maximum width in characters of `editable`.
             * @param n_chars the new desired maximum width, in characters
             */
            set_max_width_chars(n_chars: number): void;
            /**
             * Sets the cursor position in the editable to the given value.
             *
             * The cursor is displayed before the character with the given (base 0)
             * index in the contents of the editable. The value must be less than
             * or equal to the number of characters in the editable. A value of -1
             * indicates that the position should be set after the last character
             * of the editable. Note that `position` is in characters, not in bytes.
             * @param position the position of the cursor
             */
            set_position(position: number): void;
            /**
             * Sets the text in the editable to the given value.
             *
             * This is replacing the current contents.
             * @param text the text to set
             */
            set_text(text: string): void;
            /**
             * Changes the size request of the editable to be about the
             * right size for `n_chars` characters.
             *
             * Note that it changes the size request, the size can still
             * be affected by how you pack the widget into containers.
             * If `n_chars` is -1, the size reverts to the default size.
             * @param n_chars width in chars
             */
            set_width_chars(n_chars: number): void;
            vfunc_changed(): void;
            /**
             * Deletes a sequence of characters.
             *
             * The characters that are deleted are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters deleted are those from `start_pos` to
             * the end of the text.
             *
             * Note that the positions are specified in characters, not bytes.
             * @param start_pos start position
             * @param end_pos end position
             */
            vfunc_delete_text(start_pos: number, end_pos: number): void;
            /**
             * Deletes a sequence of characters.
             *
             * The characters that are deleted are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters deleted are those from `start_pos` to
             * the end of the text.
             *
             * Note that the positions are specified in characters, not bytes.
             * @param start_pos start position
             * @param end_pos end position
             */
            vfunc_do_delete_text(start_pos: number, end_pos: number): void;
            /**
             * Inserts `length` bytes of `text` into the contents of the
             * widget, at position `position`.
             *
             * Note that the position is in characters, not in bytes.
             * The function updates `position` to point after the newly
             * inserted text.
             * @param text the text to insert
             * @param length the length of the text in bytes, or -1
             * @param position location of the position text will be inserted at
             */
            vfunc_do_insert_text(text: string, length: number, position: number): number;
            /**
             * Gets the `GtkEditable` that `editable` is delegating its
             * implementation to.
             *
             * Typically, the delegate is a [class`Gtk`.Text] widget.
             */
            vfunc_get_delegate(): Editable | null;
            /**
             * Retrieves the selection bound of the editable.
             *
             * `start_pos` will be filled with the start of the selection and
             * `end_pos` with end. If no text was selected both will be identical
             * and %FALSE will be returned.
             *
             * Note that positions are specified in characters, not bytes.
             */
            vfunc_get_selection_bounds(): [boolean, number, number];
            /**
             * Retrieves the contents of `editable`.
             *
             * The returned string is owned by GTK and must not be modified or freed.
             */
            vfunc_get_text(): string;
            /**
             * Inserts `length` bytes of `text` into the contents of the
             * widget, at position `position`.
             *
             * Note that the position is in characters, not in bytes.
             * The function updates `position` to point after the newly
             * inserted text.
             * @param text the text to insert
             * @param length the length of the text in bytes, or -1
             * @param position location of the position text will be inserted at
             */
            vfunc_insert_text(text: string, length: number, position: number): number;
            /**
             * Selects a region of text.
             *
             * The characters that are selected are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters selected are those characters from
             * `start_pos` to  the end of the text.
             *
             * Note that positions are specified in characters, not bytes.
             * @param start_pos start of region
             * @param end_pos end of region
             */
            vfunc_set_selection_bounds(start_pos: number, end_pos: number): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace EmojiChooser {
            // Signal callback interfaces

            interface EmojiPicked {
                (text: string): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Popover.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Native.ConstructorProps,
                    ShortcutManager.ConstructorProps {}
        }

        /**
         * The `GtkEmojiChooser` is used by text widgets such as `GtkEntry` or
         * `GtkTextView` to let users insert Emoji characters.
         *
         * ![An example GtkEmojiChooser](emojichooser.png)
         *
         * `GtkEmojiChooser` emits the [signal`Gtk`.EmojiChooser::emoji-picked]
         * signal when an Emoji is selected.
         *
         * # Shortcuts and Gestures
         *
         * `GtkEmojiChooser` supports the following keyboard shortcuts:
         *
         * - <kbd>Ctrl</kbd>+<kbd>N</kbd> scrolls th the next section.
         * - <kbd>Ctrl</kbd>+<kbd>P</kbd> scrolls th the previous section.
         *
         * # Actions
         *
         * `GtkEmojiChooser` defines a set of built-in actions:
         *
         * - `scroll.section` scrolls to the next or previous section.
         *
         * # CSS nodes
         *
         * ```
         * popover
         * ├── box.emoji-searchbar
         * │   ╰── entry.search
         * ╰── box.emoji-toolbar
         *     ├── button.image-button.emoji-section
         *     ├── ...
         *     ╰── button.image-button.emoji-section
         * ```
         *
         * Every `GtkEmojiChooser` consists of a main node called popover.
         * The contents of the popover are largely implementation defined
         * and supposed to inherit general styles.
         * The top searchbar used to search emoji and gets the .emoji-searchbar
         * style class itself.
         * The bottom toolbar used to switch between different emoji categories
         * consists of buttons with the .emoji-section style class and gets the
         * .emoji-toolbar style class itself.
         */
        class EmojiChooser extends Popover implements Accessible, Buildable, ConstraintTarget, Native, ShortcutManager {
            static $gtype: GObject.GType<EmojiChooser>;

            // Constructors

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

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

            static ['new'](): EmojiChooser;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'emoji-picked', callback: (_source: this, text: string) => void): number;
            connect_after(signal: 'emoji-picked', callback: (_source: this, text: string) => void): number;
            emit(signal: 'emoji-picked', text: string): void;

            // Inherited properties
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Returns the renderer that is used for this `GtkNative`.
             * @returns the renderer for @self
             */
            get_renderer(): Gsk.Renderer | null;
            /**
             * Returns the surface of this `GtkNative`.
             * @returns the surface of @self
             */
            get_surface(): Gdk.Surface | null;
            /**
             * Retrieves the surface transform of `self`.
             *
             * This is the translation from `self'`s surface coordinates into
             * `self'`s widget coordinates.
             */
            get_surface_transform(): [number, number];
            /**
             * Realizes a `GtkNative`.
             *
             * This should only be used by subclasses.
             */
            realize(): void;
            /**
             * Unrealizes a `GtkNative`.
             *
             * This should only be used by subclasses.
             */
            unrealize(): void;
            /**
             * Add a `GtkShortcutController` to be managed.
             * @param controller
             */
            vfunc_add_controller(controller: ShortcutController): void;
            /**
             * Remove a `GtkShortcutController` that had previously
             *   been added
             * @param controller
             */
            vfunc_remove_controller(controller: ShortcutController): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace Entry {
            // Signal callback interfaces

            interface Activate {
                (): void;
            }

            interface IconPress {
                (icon_pos: EntryIconPosition): void;
            }

            interface IconRelease {
                (icon_pos: EntryIconPosition): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    CellEditable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Editable.ConstructorProps {
                activates_default: boolean;
                activatesDefault: boolean;
                attributes: Pango.AttrList;
                buffer: EntryBuffer;
                completion: EntryCompletion;
                enable_emoji_completion: boolean;
                enableEmojiCompletion: boolean;
                extra_menu: Gio.MenuModel;
                extraMenu: Gio.MenuModel;
                has_frame: boolean;
                hasFrame: boolean;
                im_module: string;
                imModule: string;
                input_hints: InputHints;
                inputHints: InputHints;
                input_purpose: InputPurpose;
                inputPurpose: InputPurpose;
                invisible_char: number;
                invisibleChar: number;
                invisible_char_set: boolean;
                invisibleCharSet: boolean;
                max_length: number;
                maxLength: number;
                overwrite_mode: boolean;
                overwriteMode: boolean;
                placeholder_text: string;
                placeholderText: string;
                primary_icon_activatable: boolean;
                primaryIconActivatable: boolean;
                primary_icon_gicon: Gio.Icon;
                primaryIconGicon: Gio.Icon;
                primary_icon_name: string;
                primaryIconName: string;
                primary_icon_paintable: Gdk.Paintable;
                primaryIconPaintable: Gdk.Paintable;
                primary_icon_sensitive: boolean;
                primaryIconSensitive: boolean;
                primary_icon_storage_type: ImageType;
                primaryIconStorageType: ImageType;
                primary_icon_tooltip_markup: string;
                primaryIconTooltipMarkup: string;
                primary_icon_tooltip_text: string;
                primaryIconTooltipText: string;
                progress_fraction: number;
                progressFraction: number;
                progress_pulse_step: number;
                progressPulseStep: number;
                scroll_offset: number;
                scrollOffset: number;
                secondary_icon_activatable: boolean;
                secondaryIconActivatable: boolean;
                secondary_icon_gicon: Gio.Icon;
                secondaryIconGicon: Gio.Icon;
                secondary_icon_name: string;
                secondaryIconName: string;
                secondary_icon_paintable: Gdk.Paintable;
                secondaryIconPaintable: Gdk.Paintable;
                secondary_icon_sensitive: boolean;
                secondaryIconSensitive: boolean;
                secondary_icon_storage_type: ImageType;
                secondaryIconStorageType: ImageType;
                secondary_icon_tooltip_markup: string;
                secondaryIconTooltipMarkup: string;
                secondary_icon_tooltip_text: string;
                secondaryIconTooltipText: string;
                show_emoji_icon: boolean;
                showEmojiIcon: boolean;
                tabs: Pango.TabArray;
                text_length: number;
                textLength: number;
                truncate_multiline: boolean;
                truncateMultiline: boolean;
                visibility: boolean;
            }
        }

        /**
         * `GtkEntry` is a single line text entry widget.
         *
         * ![An example GtkEntry](entry.png)
         *
         * A fairly large set of key bindings are supported by default. If the
         * entered text is longer than the allocation of the widget, the widget
         * will scroll so that the cursor position is visible.
         *
         * When using an entry for passwords and other sensitive information, it
         * can be put into “password mode” using [method`Gtk`.Entry.set_visibility].
         * In this mode, entered text is displayed using a “invisible” character.
         * By default, GTK picks the best invisible character that is available
         * in the current font, but it can be changed with
         * [method`Gtk`.Entry.set_invisible_char].
         *
         * `GtkEntry` has the ability to display progress or activity
         * information behind the text. To make an entry display such information,
         * use [method`Gtk`.Entry.set_progress_fraction] or
         * [method`Gtk`.Entry.set_progress_pulse_step].
         *
         * Additionally, `GtkEntry` can show icons at either side of the entry.
         * These icons can be activatable by clicking, can be set up as drag source
         * and can have tooltips. To add an icon, use
         * [method`Gtk`.Entry.set_icon_from_gicon] or one of the various other functions
         * that set an icon from an icon name or a paintable. To trigger an action when
         * the user clicks an icon, connect to the [signal`Gtk`.Entry::icon-press] signal.
         * To allow DND operations from an icon, use
         * [method`Gtk`.Entry.set_icon_drag_source]. To set a tooltip on an icon, use
         * [method`Gtk`.Entry.set_icon_tooltip_text] or the corresponding function
         * for markup.
         *
         * Note that functionality or information that is only available by clicking
         * on an icon in an entry may not be accessible at all to users which are not
         * able to use a mouse or other pointing device. It is therefore recommended
         * that any such functionality should also be available by other means, e.g.
         * via the context menu of the entry.
         *
         * # CSS nodes
         *
         * ```
         * entry[.flat][.warning][.error]
         * ├── text[.readonly]
         * ├── image.left
         * ├── image.right
         * ╰── [progress[.pulse]]
         * ```
         *
         * `GtkEntry` has a main node with the name entry. Depending on the properties
         * of the entry, the style classes .read-only and .flat may appear. The style
         * classes .warning and .error may also be used with entries.
         *
         * When the entry shows icons, it adds subnodes with the name image and the
         * style class .left or .right, depending on where the icon appears.
         *
         * When the entry shows progress, it adds a subnode with the name progress.
         * The node has the style class .pulse when the shown progress is pulsing.
         *
         * For all the subnodes added to the text node in various situations,
         * see [class`Gtk`.Text].
         *
         * # GtkEntry as GtkBuildable
         *
         * The `GtkEntry` implementation of the `GtkBuildable` interface supports a
         * custom `<attributes>` element, which supports any number of `<attribute>`
         * elements. The `<attribute>` element has attributes named “name“, “value“,
         * “start“ and “end“ and allows you to specify `PangoAttribute` values for
         * this label.
         *
         * An example of a UI definition fragment specifying Pango attributes:
         * ```xml
         * <object class="GtkEntry">
         *   <attributes>
         *     <attribute name="weight" value="PANGO_WEIGHT_BOLD"/>
         *     <attribute name="background" value="red" start="5" end="10"/>
         *   </attributes>
         * </object>
         * ```
         *
         * The start and end attributes specify the range of characters to which the
         * Pango attribute applies. If start and end are not specified, the attribute
         * is applied to the whole text. Note that specifying ranges does not make much
         * sense with translatable attributes. Use markup embedded in the translatable
         * content instead.
         *
         * # Accessibility
         *
         * `GtkEntry` uses the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role.
         */
        class Entry extends Widget implements Accessible, Buildable, CellEditable, ConstraintTarget, Editable {
            static $gtype: GObject.GType<Entry>;

            // Properties

            /**
             * Whether to activate the default widget when Enter is pressed.
             */
            get activates_default(): boolean;
            set activates_default(val: boolean);
            /**
             * Whether to activate the default widget when Enter is pressed.
             */
            get activatesDefault(): boolean;
            set activatesDefault(val: boolean);
            /**
             * A list of Pango attributes to apply to the text of the entry.
             *
             * This is mainly useful to change the size or weight of the text.
             *
             * The `PangoAttribute`'s `start_index` and `end_index` must refer to the
             * [class`Gtk`.EntryBuffer] text, i.e. without the preedit string.
             */
            get attributes(): Pango.AttrList;
            set attributes(val: Pango.AttrList);
            /**
             * The buffer object which actually stores the text.
             */
            get buffer(): EntryBuffer;
            set buffer(val: EntryBuffer);
            /**
             * The auxiliary completion object to use with the entry.
             */
            get completion(): EntryCompletion;
            set completion(val: EntryCompletion);
            /**
             * Whether to suggest Emoji replacements for :-delimited names
             * like `:heart:`.
             */
            get enable_emoji_completion(): boolean;
            set enable_emoji_completion(val: boolean);
            /**
             * Whether to suggest Emoji replacements for :-delimited names
             * like `:heart:`.
             */
            get enableEmojiCompletion(): boolean;
            set enableEmojiCompletion(val: boolean);
            /**
             * A menu model whose contents will be appended to the context menu.
             */
            get extra_menu(): Gio.MenuModel;
            set extra_menu(val: Gio.MenuModel);
            /**
             * A menu model whose contents will be appended to the context menu.
             */
            get extraMenu(): Gio.MenuModel;
            set extraMenu(val: Gio.MenuModel);
            /**
             * Whether the entry should draw a frame.
             */
            get has_frame(): boolean;
            set has_frame(val: boolean);
            /**
             * Whether the entry should draw a frame.
             */
            get hasFrame(): boolean;
            set hasFrame(val: boolean);
            /**
             * Which IM (input method) module should be used for this entry.
             *
             * See [class`Gtk`.IMContext].
             *
             * Setting this to a non-%NULL value overrides the system-wide IM
             * module setting. See the GtkSettings [property`Gtk`.Settings:gtk-im-module]
             * property.
             */
            get im_module(): string;
            set im_module(val: string);
            /**
             * Which IM (input method) module should be used for this entry.
             *
             * See [class`Gtk`.IMContext].
             *
             * Setting this to a non-%NULL value overrides the system-wide IM
             * module setting. See the GtkSettings [property`Gtk`.Settings:gtk-im-module]
             * property.
             */
            get imModule(): string;
            set imModule(val: string);
            /**
             * Additional hints that allow input methods to fine-tune their behavior.
             *
             * Also see [property`Gtk`.Entry:input-purpose]
             */
            get input_hints(): InputHints;
            set input_hints(val: InputHints);
            /**
             * Additional hints that allow input methods to fine-tune their behavior.
             *
             * Also see [property`Gtk`.Entry:input-purpose]
             */
            get inputHints(): InputHints;
            set inputHints(val: InputHints);
            /**
             * The purpose of this text field.
             *
             * This property can be used by on-screen keyboards and other input
             * methods to adjust their behaviour.
             *
             * Note that setting the purpose to %GTK_INPUT_PURPOSE_PASSWORD or
             * %GTK_INPUT_PURPOSE_PIN is independent from setting
             * [property`Gtk`.Entry:visibility].
             */
            get input_purpose(): InputPurpose;
            set input_purpose(val: InputPurpose);
            /**
             * The purpose of this text field.
             *
             * This property can be used by on-screen keyboards and other input
             * methods to adjust their behaviour.
             *
             * Note that setting the purpose to %GTK_INPUT_PURPOSE_PASSWORD or
             * %GTK_INPUT_PURPOSE_PIN is independent from setting
             * [property`Gtk`.Entry:visibility].
             */
            get inputPurpose(): InputPurpose;
            set inputPurpose(val: InputPurpose);
            /**
             * The character to use when masking entry contents (“password mode”).
             */
            get invisible_char(): number;
            set invisible_char(val: number);
            /**
             * The character to use when masking entry contents (“password mode”).
             */
            get invisibleChar(): number;
            set invisibleChar(val: number);
            /**
             * Whether the invisible char has been set for the `GtkEntry`.
             */
            get invisible_char_set(): boolean;
            set invisible_char_set(val: boolean);
            /**
             * Whether the invisible char has been set for the `GtkEntry`.
             */
            get invisibleCharSet(): boolean;
            set invisibleCharSet(val: boolean);
            /**
             * Maximum number of characters for this entry.
             */
            get max_length(): number;
            set max_length(val: number);
            /**
             * Maximum number of characters for this entry.
             */
            get maxLength(): number;
            set maxLength(val: number);
            /**
             * If text is overwritten when typing in the `GtkEntry`.
             */
            get overwrite_mode(): boolean;
            set overwrite_mode(val: boolean);
            /**
             * If text is overwritten when typing in the `GtkEntry`.
             */
            get overwriteMode(): boolean;
            set overwriteMode(val: boolean);
            /**
             * The text that will be displayed in the `GtkEntry` when it is empty
             * and unfocused.
             */
            get placeholder_text(): string;
            set placeholder_text(val: string);
            /**
             * The text that will be displayed in the `GtkEntry` when it is empty
             * and unfocused.
             */
            get placeholderText(): string;
            set placeholderText(val: string);
            /**
             * Whether the primary icon is activatable.
             *
             * GTK emits the [signal`Gtk`.Entry::icon-press] and
             * [signal`Gtk`.Entry::icon-release] signals only on sensitive,
             * activatable icons.
             *
             * Sensitive, but non-activatable icons can be used for purely
             * informational purposes.
             */
            get primary_icon_activatable(): boolean;
            set primary_icon_activatable(val: boolean);
            /**
             * Whether the primary icon is activatable.
             *
             * GTK emits the [signal`Gtk`.Entry::icon-press] and
             * [signal`Gtk`.Entry::icon-release] signals only on sensitive,
             * activatable icons.
             *
             * Sensitive, but non-activatable icons can be used for purely
             * informational purposes.
             */
            get primaryIconActivatable(): boolean;
            set primaryIconActivatable(val: boolean);
            /**
             * The `GIcon` to use for the primary icon for the entry.
             */
            get primary_icon_gicon(): Gio.Icon;
            set primary_icon_gicon(val: Gio.Icon);
            /**
             * The `GIcon` to use for the primary icon for the entry.
             */
            get primaryIconGicon(): Gio.Icon;
            set primaryIconGicon(val: Gio.Icon);
            /**
             * The icon name to use for the primary icon for the entry.
             */
            get primary_icon_name(): string;
            set primary_icon_name(val: string);
            /**
             * The icon name to use for the primary icon for the entry.
             */
            get primaryIconName(): string;
            set primaryIconName(val: string);
            /**
             * A `GdkPaintable` to use as the primary icon for the entry.
             */
            get primary_icon_paintable(): Gdk.Paintable;
            set primary_icon_paintable(val: Gdk.Paintable);
            /**
             * A `GdkPaintable` to use as the primary icon for the entry.
             */
            get primaryIconPaintable(): Gdk.Paintable;
            set primaryIconPaintable(val: Gdk.Paintable);
            /**
             * Whether the primary icon is sensitive.
             *
             * An insensitive icon appears grayed out. GTK does not emit the
             * [signal`Gtk`.Entry::icon-press] and [signal`Gtk`.Entry::icon-release]
             * signals and does not allow DND from insensitive icons.
             *
             * An icon should be set insensitive if the action that would trigger
             * when clicked is currently not available.
             */
            get primary_icon_sensitive(): boolean;
            set primary_icon_sensitive(val: boolean);
            /**
             * Whether the primary icon is sensitive.
             *
             * An insensitive icon appears grayed out. GTK does not emit the
             * [signal`Gtk`.Entry::icon-press] and [signal`Gtk`.Entry::icon-release]
             * signals and does not allow DND from insensitive icons.
             *
             * An icon should be set insensitive if the action that would trigger
             * when clicked is currently not available.
             */
            get primaryIconSensitive(): boolean;
            set primaryIconSensitive(val: boolean);
            /**
             * The representation which is used for the primary icon of the entry.
             */
            get primary_icon_storage_type(): ImageType;
            /**
             * The representation which is used for the primary icon of the entry.
             */
            get primaryIconStorageType(): ImageType;
            /**
             * The contents of the tooltip on the primary icon, with markup.
             *
             * Also see [method`Gtk`.Entry.set_icon_tooltip_markup].
             */
            get primary_icon_tooltip_markup(): string;
            set primary_icon_tooltip_markup(val: string);
            /**
             * The contents of the tooltip on the primary icon, with markup.
             *
             * Also see [method`Gtk`.Entry.set_icon_tooltip_markup].
             */
            get primaryIconTooltipMarkup(): string;
            set primaryIconTooltipMarkup(val: string);
            /**
             * The contents of the tooltip on the primary icon.
             *
             * Also see [method`Gtk`.Entry.set_icon_tooltip_text].
             */
            get primary_icon_tooltip_text(): string;
            set primary_icon_tooltip_text(val: string);
            /**
             * The contents of the tooltip on the primary icon.
             *
             * Also see [method`Gtk`.Entry.set_icon_tooltip_text].
             */
            get primaryIconTooltipText(): string;
            set primaryIconTooltipText(val: string);
            /**
             * The current fraction of the task that's been completed.
             */
            get progress_fraction(): number;
            set progress_fraction(val: number);
            /**
             * The current fraction of the task that's been completed.
             */
            get progressFraction(): number;
            set progressFraction(val: number);
            /**
             * The fraction of total entry width to move the progress
             * bouncing block for each pulse.
             *
             * See [method`Gtk`.Entry.progress_pulse].
             */
            get progress_pulse_step(): number;
            set progress_pulse_step(val: number);
            /**
             * The fraction of total entry width to move the progress
             * bouncing block for each pulse.
             *
             * See [method`Gtk`.Entry.progress_pulse].
             */
            get progressPulseStep(): number;
            set progressPulseStep(val: number);
            /**
             * Number of pixels of the entry scrolled off the screen to the left.
             */
            get scroll_offset(): number;
            /**
             * Number of pixels of the entry scrolled off the screen to the left.
             */
            get scrollOffset(): number;
            /**
             * Whether the secondary icon is activatable.
             *
             * GTK emits the [signal`Gtk`.Entry::icon-press] and
             * [signal`Gtk`.Entry::icon-release] signals only on sensitive,
             * activatable icons.
             *
             * Sensitive, but non-activatable icons can be used for purely
             * informational purposes.
             */
            get secondary_icon_activatable(): boolean;
            set secondary_icon_activatable(val: boolean);
            /**
             * Whether the secondary icon is activatable.
             *
             * GTK emits the [signal`Gtk`.Entry::icon-press] and
             * [signal`Gtk`.Entry::icon-release] signals only on sensitive,
             * activatable icons.
             *
             * Sensitive, but non-activatable icons can be used for purely
             * informational purposes.
             */
            get secondaryIconActivatable(): boolean;
            set secondaryIconActivatable(val: boolean);
            /**
             * The `GIcon` to use for the secondary icon for the entry.
             */
            get secondary_icon_gicon(): Gio.Icon;
            set secondary_icon_gicon(val: Gio.Icon);
            /**
             * The `GIcon` to use for the secondary icon for the entry.
             */
            get secondaryIconGicon(): Gio.Icon;
            set secondaryIconGicon(val: Gio.Icon);
            /**
             * The icon name to use for the secondary icon for the entry.
             */
            get secondary_icon_name(): string;
            set secondary_icon_name(val: string);
            /**
             * The icon name to use for the secondary icon for the entry.
             */
            get secondaryIconName(): string;
            set secondaryIconName(val: string);
            /**
             * A `GdkPaintable` to use as the secondary icon for the entry.
             */
            get secondary_icon_paintable(): Gdk.Paintable;
            set secondary_icon_paintable(val: Gdk.Paintable);
            /**
             * A `GdkPaintable` to use as the secondary icon for the entry.
             */
            get secondaryIconPaintable(): Gdk.Paintable;
            set secondaryIconPaintable(val: Gdk.Paintable);
            /**
             * Whether the secondary icon is sensitive.
             *
             * An insensitive icon appears grayed out. GTK does not emit the
             * [signal`Gtk`.Entry::icon-press[ and [signal`Gtk`.Entry::icon-release]
             * signals and does not allow DND from insensitive icons.
             *
             * An icon should be set insensitive if the action that would trigger
             * when clicked is currently not available.
             */
            get secondary_icon_sensitive(): boolean;
            set secondary_icon_sensitive(val: boolean);
            /**
             * Whether the secondary icon is sensitive.
             *
             * An insensitive icon appears grayed out. GTK does not emit the
             * [signal`Gtk`.Entry::icon-press[ and [signal`Gtk`.Entry::icon-release]
             * signals and does not allow DND from insensitive icons.
             *
             * An icon should be set insensitive if the action that would trigger
             * when clicked is currently not available.
             */
            get secondaryIconSensitive(): boolean;
            set secondaryIconSensitive(val: boolean);
            /**
             * The representation which is used for the secondary icon of the entry.
             */
            get secondary_icon_storage_type(): ImageType;
            /**
             * The representation which is used for the secondary icon of the entry.
             */
            get secondaryIconStorageType(): ImageType;
            /**
             * The contents of the tooltip on the secondary icon, with markup.
             *
             * Also see [method`Gtk`.Entry.set_icon_tooltip_markup].
             */
            get secondary_icon_tooltip_markup(): string;
            set secondary_icon_tooltip_markup(val: string);
            /**
             * The contents of the tooltip on the secondary icon, with markup.
             *
             * Also see [method`Gtk`.Entry.set_icon_tooltip_markup].
             */
            get secondaryIconTooltipMarkup(): string;
            set secondaryIconTooltipMarkup(val: string);
            /**
             * The contents of the tooltip on the secondary icon.
             *
             * Also see [method`Gtk`.Entry.set_icon_tooltip_text].
             */
            get secondary_icon_tooltip_text(): string;
            set secondary_icon_tooltip_text(val: string);
            /**
             * The contents of the tooltip on the secondary icon.
             *
             * Also see [method`Gtk`.Entry.set_icon_tooltip_text].
             */
            get secondaryIconTooltipText(): string;
            set secondaryIconTooltipText(val: string);
            /**
             * Whether the entry will show an Emoji icon in the secondary icon position
             * to open the Emoji chooser.
             */
            get show_emoji_icon(): boolean;
            set show_emoji_icon(val: boolean);
            /**
             * Whether the entry will show an Emoji icon in the secondary icon position
             * to open the Emoji chooser.
             */
            get showEmojiIcon(): boolean;
            set showEmojiIcon(val: boolean);
            /**
             * A list of tabstops to apply to the text of the entry.
             */
            get tabs(): Pango.TabArray;
            set tabs(val: Pango.TabArray);
            /**
             * The length of the text in the `GtkEntry`.
             */
            get text_length(): number;
            /**
             * The length of the text in the `GtkEntry`.
             */
            get textLength(): number;
            /**
             * When %TRUE, pasted multi-line text is truncated to the first line.
             */
            get truncate_multiline(): boolean;
            set truncate_multiline(val: boolean);
            /**
             * When %TRUE, pasted multi-line text is truncated to the first line.
             */
            get truncateMultiline(): boolean;
            set truncateMultiline(val: boolean);
            /**
             * Whether the entry should show the “invisible char” instead of the
             * actual text (“password mode”).
             */
            get visibility(): boolean;
            set visibility(val: boolean);

            // Constructors

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

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

            static ['new'](): Entry;

            static new_with_buffer(buffer: EntryBuffer): Entry;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate', callback: (_source: this) => void): number;
            connect_after(signal: 'activate', callback: (_source: this) => void): number;
            emit(signal: 'activate'): void;
            connect(signal: 'icon-press', callback: (_source: this, icon_pos: EntryIconPosition) => void): number;
            connect_after(signal: 'icon-press', callback: (_source: this, icon_pos: EntryIconPosition) => void): number;
            emit(signal: 'icon-press', icon_pos: EntryIconPosition): void;
            connect(signal: 'icon-release', callback: (_source: this, icon_pos: EntryIconPosition) => void): number;
            connect_after(
                signal: 'icon-release',
                callback: (_source: this, icon_pos: EntryIconPosition) => void,
            ): number;
            emit(signal: 'icon-release', icon_pos: EntryIconPosition): void;

            // Virtual methods

            /**
             * Class handler for the `GtkEntry::activate` signal. The default
             *   implementation activates the gtk.activate-default action.
             */
            vfunc_activate(): void;

            // Methods

            /**
             * Retrieves the value set by gtk_entry_set_activates_default().
             * @returns %TRUE if the entry will activate the default widget
             */
            get_activates_default(): boolean;
            /**
             * Gets the value set by gtk_entry_set_alignment().
             *
             * See also: [property`Gtk`.Editable:xalign]
             * @returns the alignment
             */
            get_alignment(): number;
            /**
             * Gets the attribute list of the `GtkEntry`.
             *
             * See [method`Gtk`.Entry.set_attributes].
             * @returns the attribute list
             */
            get_attributes(): Pango.AttrList | null;
            /**
             * Get the `GtkEntryBuffer` object which holds the text for
             * this widget.
             * @returns A `GtkEntryBuffer` object.
             */
            get_buffer(): EntryBuffer;
            /**
             * Returns the auxiliary completion object currently
             * in use by `entry`.
             * @returns The auxiliary   completion object currently in use by @entry
             */
            get_completion(): EntryCompletion | null;
            /**
             * Returns the index of the icon which is the source of the
             * current  DND operation, or -1.
             * @returns index of the icon which is the source of the   current DND operation, or -1.
             */
            get_current_icon_drag_source(): number;
            /**
             * Gets the menu model set with gtk_entry_set_extra_menu().
             * @returns the menu model
             */
            get_extra_menu(): Gio.MenuModel | null;
            /**
             * Gets the value set by gtk_entry_set_has_frame().
             * @returns whether the entry has a beveled frame
             */
            get_has_frame(): boolean;
            /**
             * Returns whether the icon is activatable.
             * @param icon_pos Icon position
             * @returns %TRUE if the icon is activatable.
             */
            get_icon_activatable(icon_pos: EntryIconPosition | null): boolean;
            /**
             * Gets the area where entry’s icon at `icon_pos` is drawn.
             *
             * This function is useful when drawing something to the
             * entry in a draw callback.
             *
             * If the entry is not realized or has no icon at the given
             * position, `icon_area` is filled with zeros. Otherwise,
             * `icon_area` will be filled with the icon's allocation,
             * relative to `entry'`s allocation.
             * @param icon_pos Icon position
             */
            get_icon_area(icon_pos: EntryIconPosition | null): Gdk.Rectangle;
            /**
             * Finds the icon at the given position and return its index.
             *
             * The position’s coordinates are relative to the `entry’`s
             * top left corner. If `x,` `y` doesn’t lie inside an icon,
             * -1 is returned. This function is intended for use in a
             *  [signal`Gtk`.Widget::query-tooltip] signal handler.
             * @param x the x coordinate of the position to find, relative to @entry
             * @param y the y coordinate of the position to find, relative to @entry
             * @returns the index of the icon at the given position, or -1
             */
            get_icon_at_pos(x: number, y: number): number;
            /**
             * Retrieves the `GIcon` used for the icon.
             *
             * %NULL will be returned if there is no icon or if the icon was
             * set by some other method (e.g., by `GdkPaintable` or icon name).
             * @param icon_pos Icon position
             * @returns A `GIcon`
             */
            get_icon_gicon(icon_pos: EntryIconPosition | null): Gio.Icon | null;
            /**
             * Retrieves the icon name used for the icon.
             *
             * %NULL is returned if there is no icon or if the icon was set
             * by some other method (e.g., by `GdkPaintable` or gicon).
             * @param icon_pos Icon position
             * @returns An icon name
             */
            get_icon_name(icon_pos: EntryIconPosition | null): string | null;
            /**
             * Retrieves the `GdkPaintable` used for the icon.
             *
             * If no `GdkPaintable` was used for the icon, %NULL is returned.
             * @param icon_pos Icon position
             * @returns A `GdkPaintable`   if no icon is set for this position or the icon set is not   a `GdkPaintable`.
             */
            get_icon_paintable(icon_pos: EntryIconPosition | null): Gdk.Paintable | null;
            /**
             * Returns whether the icon appears sensitive or insensitive.
             * @param icon_pos Icon position
             * @returns %TRUE if the icon is sensitive.
             */
            get_icon_sensitive(icon_pos: EntryIconPosition | null): boolean;
            /**
             * Gets the type of representation being used by the icon
             * to store image data.
             *
             * If the icon has no image data, the return value will
             * be %GTK_IMAGE_EMPTY.
             * @param icon_pos Icon position
             * @returns image representation being used
             */
            get_icon_storage_type(icon_pos: EntryIconPosition | null): ImageType;
            /**
             * Gets the contents of the tooltip on the icon at the specified
             * position in `entry`.
             * @param icon_pos the icon position
             * @returns the tooltip text
             */
            get_icon_tooltip_markup(icon_pos: EntryIconPosition | null): string | null;
            /**
             * Gets the contents of the tooltip on the icon at the specified
             * position in `entry`.
             * @param icon_pos the icon position
             * @returns the tooltip text
             */
            get_icon_tooltip_text(icon_pos: EntryIconPosition | null): string | null;
            /**
             * Gets the input hints of this `GtkEntry`.
             * @returns the input hints
             */
            get_input_hints(): InputHints;
            /**
             * Gets the input purpose of the `GtkEntry`.
             * @returns the input purpose
             */
            get_input_purpose(): InputPurpose;
            /**
             * Retrieves the character displayed in place of the actual text
             * in “password mode”.
             * @returns the current invisible char, or 0, if the entry does not   show invisible text at all.
             */
            get_invisible_char(): number;
            /**
             * Retrieves the maximum allowed length of the text in `entry`.
             *
             * See [method`Gtk`.Entry.set_max_length].
             * @returns the maximum allowed number of characters   in `GtkEntry`, or 0 if there is no maximum.
             */
            get_max_length(): number;
            /**
             * Gets whether the `GtkEntry` is in overwrite mode.
             * @returns whether the text is overwritten when typing.
             */
            get_overwrite_mode(): boolean;
            /**
             * Retrieves the text that will be displayed when `entry`
             * is empty and unfocused
             * @returns a pointer to the   placeholder text as a string. This string points to   internally allocated storage in the widget and must   not be freed, modified or stored. If no placeholder   text has been set, %NULL will be returned.
             */
            get_placeholder_text(): string | null;
            /**
             * Returns the current fraction of the task that’s been completed.
             *
             * See [method`Gtk`.Entry.set_progress_fraction].
             * @returns a fraction from 0.0 to 1.0
             */
            get_progress_fraction(): number;
            /**
             * Retrieves the pulse step set with
             * gtk_entry_set_progress_pulse_step().
             * @returns a fraction from 0.0 to 1.0
             */
            get_progress_pulse_step(): number;
            /**
             * Gets the tabstops of the `GtkEntry`.
             *
             * See [method`Gtk`.Entry.set_tabs].
             * @returns the tabstops
             */
            get_tabs(): Pango.TabArray | null;
            /**
             * Retrieves the current length of the text in `entry`.
             *
             * This is equivalent to getting `entry'`s `GtkEntryBuffer`
             * and calling [method`Gtk`.EntryBuffer.get_length] on it.
             * @returns the current number of characters   in `GtkEntry`, or 0 if there are none.
             */
            get_text_length(): number;
            /**
             * Retrieves whether the text in `entry` is visible.
             *
             * See [method`Gtk`.Entry.set_visibility].
             * @returns %TRUE if the text is currently visible
             */
            get_visibility(): boolean;
            /**
             * Causes `entry` to have keyboard focus.
             *
             * It behaves like [method`Gtk`.Widget.grab_focus], except that it doesn't
             * select the contents of the entry. You only want to call this on some
             * special entries which the user usually doesn't want to replace all text
             * in, such as search-as-you-type entries.
             * @returns %TRUE if focus is now inside @self
             */
            grab_focus_without_selecting(): boolean;
            /**
             * Indicates that some progress is made, but you don’t
             * know how much.
             *
             * Causes the entry’s progress indicator to enter “activity
             * mode”, where a block bounces back and forth. Each call to
             * gtk_entry_progress_pulse() causes the block to move by a
             * little bit (the amount of movement per pulse is determined
             * by [method`Gtk`.Entry.set_progress_pulse_step]).
             */
            progress_pulse(): void;
            /**
             * Reset the input method context of the entry if needed.
             *
             * This can be necessary in the case where modifying the buffer
             * would confuse on-going input method behavior.
             */
            reset_im_context(): void;
            /**
             * Sets whether pressing Enter in the `entry` will activate the default
             * widget for the window containing the entry.
             *
             * This usually means that the dialog containing the entry will be closed,
             * since the default widget is usually one of the dialog buttons.
             * @param setting %TRUE to activate window’s default widget on Enter keypress
             */
            set_activates_default(setting: boolean): void;
            /**
             * Sets the alignment for the contents of the entry.
             *
             * This controls the horizontal positioning of the contents when
             * the displayed text is shorter than the width of the entry.
             *
             * See also: [property`Gtk`.Editable:xalign]
             * @param xalign The horizontal alignment, from 0 (left) to 1 (right).   Reversed for RTL layouts
             */
            set_alignment(xalign: number): void;
            /**
             * Sets a `PangoAttrList`.
             *
             * The attributes in the list are applied to the entry text.
             *
             * Since the attributes will be applied to text that changes
             * as the user types, it makes most sense to use attributes
             * with unlimited extent.
             * @param attrs a `PangoAttrList`
             */
            set_attributes(attrs: Pango.AttrList): void;
            /**
             * Set the `GtkEntryBuffer` object which holds the text for
             * this widget.
             * @param buffer a `GtkEntryBuffer`
             */
            set_buffer(buffer: EntryBuffer): void;
            /**
             * Sets `completion` to be the auxiliary completion object
             * to use with `entry`.
             *
             * All further configuration of the completion mechanism is
             * done on `completion` using the `GtkEntryCompletion` API.
             * Completion is disabled if `completion` is set to %NULL.
             * @param completion The `GtkEntryCompletion`
             */
            set_completion(completion?: EntryCompletion | null): void;
            /**
             * Sets a menu model to add when constructing
             * the context menu for `entry`.
             * @param model a `GMenuModel`
             */
            set_extra_menu(model?: Gio.MenuModel | null): void;
            /**
             * Sets whether the entry has a beveled frame around it.
             * @param setting new value
             */
            set_has_frame(setting: boolean): void;
            /**
             * Sets whether the icon is activatable.
             * @param icon_pos Icon position
             * @param activatable %TRUE if the icon should be activatable
             */
            set_icon_activatable(icon_pos: EntryIconPosition | null, activatable: boolean): void;
            /**
             * Sets up the icon at the given position as drag source.
             *
             * This makes it so that GTK will start a drag
             * operation when the user clicks and drags the icon.
             * @param icon_pos icon position
             * @param provider a `GdkContentProvider`
             * @param actions a bitmask of the allowed drag actions
             */
            set_icon_drag_source(
                icon_pos: EntryIconPosition | null,
                provider: Gdk.ContentProvider,
                actions: Gdk.DragAction | null,
            ): void;
            /**
             * Sets the icon shown in the entry at the specified position
             * from the current icon theme.
             *
             * If the icon isn’t known, a “broken image” icon will be
             * displayed instead.
             *
             * If `icon` is %NULL, no icon will be shown in the
             * specified position.
             * @param icon_pos The position at which to set the icon
             * @param icon The icon to set
             */
            set_icon_from_gicon(icon_pos: EntryIconPosition | null, icon?: Gio.Icon | null): void;
            /**
             * Sets the icon shown in the entry at the specified position
             * from the current icon theme.
             *
             * If the icon name isn’t known, a “broken image” icon will be
             * displayed instead.
             *
             * If `icon_name` is %NULL, no icon will be shown in the
             * specified position.
             * @param icon_pos The position at which to set the icon
             * @param icon_name An icon name
             */
            set_icon_from_icon_name(icon_pos: EntryIconPosition | null, icon_name?: string | null): void;
            /**
             * Sets the icon shown in the specified position using a `GdkPaintable`.
             *
             * If `paintable` is %NULL, no icon will be shown in the specified position.
             * @param icon_pos Icon position
             * @param paintable A `GdkPaintable`
             */
            set_icon_from_paintable(icon_pos: EntryIconPosition | null, paintable?: Gdk.Paintable | null): void;
            /**
             * Sets the sensitivity for the specified icon.
             * @param icon_pos Icon position
             * @param sensitive Specifies whether the icon should appear   sensitive or insensitive
             */
            set_icon_sensitive(icon_pos: EntryIconPosition | null, sensitive: boolean): void;
            /**
             * Sets `tooltip` as the contents of the tooltip for the icon at
             * the specified position.
             *
             * `tooltip` is assumed to be marked up with Pango Markup.
             *
             * Use %NULL for `tooltip` to remove an existing tooltip.
             *
             * See also [method`Gtk`.Widget.set_tooltip_markup] and
             * [method`Gtk`.Entry.set_icon_tooltip_text].
             * @param icon_pos the icon position
             * @param tooltip the contents of the tooltip for the icon
             */
            set_icon_tooltip_markup(icon_pos: EntryIconPosition | null, tooltip?: string | null): void;
            /**
             * Sets `tooltip` as the contents of the tooltip for the icon
             * at the specified position.
             *
             * Use %NULL for `tooltip` to remove an existing tooltip.
             *
             * See also [method`Gtk`.Widget.set_tooltip_text] and
             * [method`Gtk`.Entry.set_icon_tooltip_markup].
             *
             * If you unset the widget tooltip via
             * [method`Gtk`.Widget.set_tooltip_text] or
             * [method`Gtk`.Widget.set_tooltip_markup], this sets
             * [property`Gtk`.Widget:has-tooltip] to %FALSE, which suppresses
             * icon tooltips too. You can resolve this by then calling
             * [method`Gtk`.Widget.set_has_tooltip] to set
             * [property`Gtk`.Widget:has-tooltip] back to %TRUE, or
             * setting at least one non-empty tooltip on any icon
             * achieves the same result.
             * @param icon_pos the icon position
             * @param tooltip the contents of the tooltip for the icon
             */
            set_icon_tooltip_text(icon_pos: EntryIconPosition | null, tooltip?: string | null): void;
            /**
             * Set additional hints which allow input methods to
             * fine-tune their behavior.
             * @param hints the hints
             */
            set_input_hints(hints: InputHints | null): void;
            /**
             * Sets the input purpose which can be used by input methods
             * to adjust their behavior.
             * @param purpose the purpose
             */
            set_input_purpose(purpose: InputPurpose | null): void;
            /**
             * Sets the character to use in place of the actual text
             * in “password mode”.
             *
             * See [method`Gtk`.Entry.set_visibility] for how to enable
             * “password mode”.
             *
             * By default, GTK picks the best invisible char available in
             * the current font. If you set the invisible char to 0, then
             * the user will get no feedback at all; there will be no text
             * on the screen as they type.
             * @param ch a Unicode character
             */
            set_invisible_char(ch: number): void;
            /**
             * Sets the maximum allowed length of the contents of the widget.
             *
             * If the current contents are longer than the given length, then
             * they will be truncated to fit. The length is in characters.
             *
             * This is equivalent to getting `entry'`s `GtkEntryBuffer` and
             * calling [method`Gtk`.EntryBuffer.set_max_length] on it.
             * @param max the maximum length of the entry, or 0 for no maximum.   (other than the maximum length of entries.) The value passed in will   be clamped to the range 0-65536.
             */
            set_max_length(max: number): void;
            /**
             * Sets whether the text is overwritten when typing in the `GtkEntry`.
             * @param overwrite new value
             */
            set_overwrite_mode(overwrite: boolean): void;
            /**
             * Sets text to be displayed in `entry` when it is empty.
             *
             * This can be used to give a visual hint of the expected
             * contents of the `GtkEntry`.
             * @param text a string to be displayed when @entry is empty and unfocused
             */
            set_placeholder_text(text?: string | null): void;
            /**
             * Causes the entry’s progress indicator to “fill in” the given
             * fraction of the bar.
             *
             * The fraction should be between 0.0 and 1.0, inclusive.
             * @param fraction fraction of the task that’s been completed
             */
            set_progress_fraction(fraction: number): void;
            /**
             * Sets the fraction of total entry width to move the progress
             * bouncing block for each pulse.
             *
             * Use [method`Gtk`.Entry.progress_pulse] to pulse
             * the progress.
             * @param fraction fraction between 0.0 and 1.0
             */
            set_progress_pulse_step(fraction: number): void;
            /**
             * Sets a `PangoTabArray`.
             *
             * The tabstops in the array are applied to the entry text.
             * @param tabs a `PangoTabArray`
             */
            set_tabs(tabs?: Pango.TabArray | null): void;
            /**
             * Sets whether the contents of the entry are visible or not.
             *
             * When visibility is set to %FALSE, characters are displayed
             * as the invisible char, and will also appear that way when
             * the text in the entry widget is copied elsewhere.
             *
             * By default, GTK picks the best invisible character available
             * in the current font, but it can be changed with
             * [method`Gtk`.Entry.set_invisible_char].
             *
             * Note that you probably want to set [property`Gtk`.Entry:input-purpose]
             * to %GTK_INPUT_PURPOSE_PASSWORD or %GTK_INPUT_PURPOSE_PIN to
             * inform input methods about the purpose of this entry,
             * in addition to setting visibility to %FALSE.
             * @param visible %TRUE if the contents of the entry are displayed as plaintext
             */
            set_visibility(visible: boolean): void;
            /**
             * Unsets the invisible char, so that the default invisible char
             * is used again. See [method`Gtk`.Entry.set_invisible_char].
             */
            unset_invisible_char(): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * Indicates whether editing on the cell has been canceled.
             */
            get editing_canceled(): boolean;
            set editing_canceled(val: boolean);
            /**
             * Indicates whether editing on the cell has been canceled.
             */
            get editingCanceled(): boolean;
            set editingCanceled(val: boolean);
            /**
             * The current position of the insertion cursor in chars.
             */
            get cursor_position(): number;
            /**
             * The current position of the insertion cursor in chars.
             */
            get cursorPosition(): number;
            /**
             * Whether the entry contents can be edited.
             */
            get editable(): boolean;
            set editable(val: boolean);
            /**
             * If undo/redo should be enabled for the editable.
             */
            get enable_undo(): boolean;
            set enable_undo(val: boolean);
            /**
             * If undo/redo should be enabled for the editable.
             */
            get enableUndo(): boolean;
            set enableUndo(val: boolean);
            /**
             * The desired maximum width of the entry, in characters.
             */
            get max_width_chars(): number;
            set max_width_chars(val: number);
            /**
             * The desired maximum width of the entry, in characters.
             */
            get maxWidthChars(): number;
            set maxWidthChars(val: number);
            /**
             * The position of the opposite end of the selection from the cursor in chars.
             */
            get selection_bound(): number;
            /**
             * The position of the opposite end of the selection from the cursor in chars.
             */
            get selectionBound(): number;
            /**
             * The contents of the entry.
             */
            get text(): string;
            set text(val: string);
            /**
             * Number of characters to leave space for in the entry.
             */
            get width_chars(): number;
            set width_chars(val: number);
            /**
             * Number of characters to leave space for in the entry.
             */
            get widthChars(): number;
            set widthChars(val: number);
            /**
             * The horizontal alignment, from 0 (left) to 1 (right).
             *
             * Reversed for RTL layouts.
             */
            get xalign(): number;
            set xalign(val: number);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Emits the `GtkCellEditable::editing-done` signal.
             */
            editing_done(): void;
            /**
             * Emits the `GtkCellEditable::remove-widget` signal.
             */
            remove_widget(): void;
            /**
             * Begins editing on a `cell_editable`.
             *
             * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
             * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
             *
             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
             * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
             *
             * Note that the `cell_editable` is created on-demand for the current edit; its
             * lifetime is temporary and does not persist across other edits and/or cells.
             * @param event The `GdkEvent` that began the editing process, or   %NULL if editing was initiated programmatically
             */
            start_editing(event?: Gdk.Event | null): void;
            /**
             * Emits the `GtkCellEditable::editing-done` signal.
             */
            vfunc_editing_done(): void;
            /**
             * Emits the `GtkCellEditable::remove-widget` signal.
             */
            vfunc_remove_widget(): void;
            /**
             * Begins editing on a `cell_editable`.
             *
             * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
             * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
             *
             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
             * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
             *
             * Note that the `cell_editable` is created on-demand for the current edit; its
             * lifetime is temporary and does not persist across other edits and/or cells.
             * @param event The `GdkEvent` that began the editing process, or   %NULL if editing was initiated programmatically
             */
            vfunc_start_editing(event?: Gdk.Event | null): void;
            /**
             * Retrieves the accessible platform state from the editable delegate.
             *
             * This is an helper function to retrieve the accessible state for
             * `GtkEditable` interface implementations using a delegate pattern.
             *
             * You should call this function in your editable widget implementation
             * of the [vfunc`Gtk`.Accessible.get_platform_state] virtual function, for
             * instance:
             *
             * ```c
             * static void
             * accessible_interface_init (GtkAccessibleInterface *iface)
             * {
             *   iface->get_platform_state = your_editable_get_accessible_platform_state;
             * }
             *
             * static gboolean
             * your_editable_get_accessible_platform_state (GtkAccessible *accessible,
             *                                              GtkAccessiblePlatformState state)
             * {
             *   return gtk_editable_delegate_get_accessible_platform_state (GTK_EDITABLE (accessible), state);
             * }
             * ```
             *
             * Note that the widget which is the delegate *must* be a direct child of
             * this widget, otherwise your implementation of [vfunc`Gtk`.Accessible.get_platform_state]
             * might not even be called, as the platform change will originate from
             * the parent of the delegate, and, as a result, will not work properly.
             *
             * So, if you can't ensure the direct child condition, you should give the
             * delegate the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role, or you can
             * change your tree to allow this function to work.
             * @param state what kind of accessible state to retrieve
             * @returns the accessible platform state of the delegate
             */
            delegate_get_accessible_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Deletes the currently selected text of the editable.
             *
             * This call doesn’t do anything if there is no selected text.
             */
            delete_selection(): void;
            /**
             * Deletes a sequence of characters.
             *
             * The characters that are deleted are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters deleted are those from `start_pos` to
             * the end of the text.
             *
             * Note that the positions are specified in characters, not bytes.
             * @param start_pos start position
             * @param end_pos end position
             */
            delete_text(start_pos: number, end_pos: number): void;
            /**
             * Undoes the setup done by [method`Gtk`.Editable.init_delegate].
             *
             * This is a helper function that should be called from dispose,
             * before removing the delegate object.
             */
            finish_delegate(): void;
            /**
             * Retrieves a sequence of characters.
             *
             * The characters that are retrieved are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is negative,
             * then the characters retrieved are those characters from `start_pos` to
             * the end of the text.
             *
             * Note that positions are specified in characters, not bytes.
             * @param start_pos start of text
             * @param end_pos end of text
             * @returns a pointer to the contents of the widget as a   string. This string is allocated by the `GtkEditable` implementation   and should be freed by the caller.
             */
            get_chars(start_pos: number, end_pos: number): string;
            /**
             * Gets the `GtkEditable` that `editable` is delegating its
             * implementation to.
             *
             * Typically, the delegate is a [class`Gtk`.Text] widget.
             * @returns the delegate `GtkEditable`
             */
            get_delegate(): Editable | null;
            /**
             * Retrieves whether `editable` is editable.
             * @returns %TRUE if @editable is editable.
             */
            get_editable(): boolean;
            /**
             * Gets if undo/redo actions are enabled for `editable`
             * @returns %TRUE if undo is enabled
             */
            get_enable_undo(): boolean;
            /**
             * Retrieves the desired maximum width of `editable,` in characters.
             * @returns the maximum width of the entry, in characters
             */
            get_max_width_chars(): number;
            /**
             * Retrieves the current position of the cursor relative
             * to the start of the content of the editable.
             *
             * Note that this position is in characters, not in bytes.
             * @returns the cursor position
             */
            get_position(): number;
            /**
             * Retrieves the selection bound of the editable.
             *
             * `start_pos` will be filled with the start of the selection and
             * `end_pos` with end. If no text was selected both will be identical
             * and %FALSE will be returned.
             *
             * Note that positions are specified in characters, not bytes.
             * @returns %TRUE if there is a non-empty selection, %FALSE otherwise
             */
            get_selection_bounds(): [boolean, number, number];
            /**
             * Retrieves the contents of `editable`.
             *
             * The returned string is owned by GTK and must not be modified or freed.
             * @returns a pointer to the contents of the editable
             */
            get_text(): string;
            /**
             * Gets the number of characters of space reserved
             * for the contents of the editable.
             * @returns number of chars to request space for, or negative if unset
             */
            get_width_chars(): number;
            /**
             * Sets up a delegate for `GtkEditable`.
             *
             * This is assuming that the get_delegate vfunc in the `GtkEditable`
             * interface has been set up for the `editable'`s type.
             *
             * This is a helper function that should be called in instance init,
             * after creating the delegate object.
             */
            init_delegate(): void;
            /**
             * Inserts `length` bytes of `text` into the contents of the
             * widget, at position `position`.
             *
             * Note that the position is in characters, not in bytes.
             * The function updates `position` to point after the newly
             * inserted text.
             * @param text the text to insert
             * @param length the length of the text in bytes, or -1
             * @param position location of the position text will be inserted at
             */
            insert_text(text: string, length: number, position: number): number;
            /**
             * Selects a region of text.
             *
             * The characters that are selected are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters selected are those characters from
             * `start_pos` to  the end of the text.
             *
             * Note that positions are specified in characters, not bytes.
             * @param start_pos start of region
             * @param end_pos end of region
             */
            select_region(start_pos: number, end_pos: number): void;
            /**
             * Determines if the user can edit the text in the editable widget.
             * @param is_editable %TRUE if the user is allowed to edit the text   in the widget
             */
            set_editable(is_editable: boolean): void;
            /**
             * If enabled, changes to `editable` will be saved for undo/redo
             * actions.
             *
             * This results in an additional copy of text changes and are not
             * stored in secure memory. As such, undo is forcefully disabled
             * when [property`Gtk`.Text:visibility] is set to %FALSE.
             * @param enable_undo if undo/redo should be enabled
             */
            set_enable_undo(enable_undo: boolean): void;
            /**
             * Sets the desired maximum width in characters of `editable`.
             * @param n_chars the new desired maximum width, in characters
             */
            set_max_width_chars(n_chars: number): void;
            /**
             * Sets the cursor position in the editable to the given value.
             *
             * The cursor is displayed before the character with the given (base 0)
             * index in the contents of the editable. The value must be less than
             * or equal to the number of characters in the editable. A value of -1
             * indicates that the position should be set after the last character
             * of the editable. Note that `position` is in characters, not in bytes.
             * @param position the position of the cursor
             */
            set_position(position: number): void;
            /**
             * Sets the text in the editable to the given value.
             *
             * This is replacing the current contents.
             * @param text the text to set
             */
            set_text(text: string): void;
            /**
             * Changes the size request of the editable to be about the
             * right size for `n_chars` characters.
             *
             * Note that it changes the size request, the size can still
             * be affected by how you pack the widget into containers.
             * If `n_chars` is -1, the size reverts to the default size.
             * @param n_chars width in chars
             */
            set_width_chars(n_chars: number): void;
            vfunc_changed(): void;
            /**
             * Deletes a sequence of characters.
             *
             * The characters that are deleted are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters deleted are those from `start_pos` to
             * the end of the text.
             *
             * Note that the positions are specified in characters, not bytes.
             * @param start_pos start position
             * @param end_pos end position
             */
            vfunc_delete_text(start_pos: number, end_pos: number): void;
            /**
             * Deletes a sequence of characters.
             *
             * The characters that are deleted are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters deleted are those from `start_pos` to
             * the end of the text.
             *
             * Note that the positions are specified in characters, not bytes.
             * @param start_pos start position
             * @param end_pos end position
             */
            vfunc_do_delete_text(start_pos: number, end_pos: number): void;
            /**
             * Inserts `length` bytes of `text` into the contents of the
             * widget, at position `position`.
             *
             * Note that the position is in characters, not in bytes.
             * The function updates `position` to point after the newly
             * inserted text.
             * @param text the text to insert
             * @param length the length of the text in bytes, or -1
             * @param position location of the position text will be inserted at
             */
            vfunc_do_insert_text(text: string, length: number, position: number): number;
            /**
             * Gets the `GtkEditable` that `editable` is delegating its
             * implementation to.
             *
             * Typically, the delegate is a [class`Gtk`.Text] widget.
             */
            vfunc_get_delegate(): Editable | null;
            /**
             * Retrieves the selection bound of the editable.
             *
             * `start_pos` will be filled with the start of the selection and
             * `end_pos` with end. If no text was selected both will be identical
             * and %FALSE will be returned.
             *
             * Note that positions are specified in characters, not bytes.
             */
            vfunc_get_selection_bounds(): [boolean, number, number];
            /**
             * Retrieves the contents of `editable`.
             *
             * The returned string is owned by GTK and must not be modified or freed.
             */
            vfunc_get_text(): string;
            /**
             * Inserts `length` bytes of `text` into the contents of the
             * widget, at position `position`.
             *
             * Note that the position is in characters, not in bytes.
             * The function updates `position` to point after the newly
             * inserted text.
             * @param text the text to insert
             * @param length the length of the text in bytes, or -1
             * @param position location of the position text will be inserted at
             */
            vfunc_insert_text(text: string, length: number, position: number): number;
            /**
             * Selects a region of text.
             *
             * The characters that are selected are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters selected are those characters from
             * `start_pos` to  the end of the text.
             *
             * Note that positions are specified in characters, not bytes.
             * @param start_pos start of region
             * @param end_pos end of region
             */
            vfunc_set_selection_bounds(start_pos: number, end_pos: number): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace EntryBuffer {
            // Signal callback interfaces

            interface DeletedText {
                (position: number, n_chars: number): void;
            }

            interface InsertedText {
                (position: number, chars: string, n_chars: number): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                length: number;
                max_length: number;
                maxLength: number;
                text: string;
            }
        }

        /**
         * A `GtkEntryBuffer` hold the text displayed in a `GtkText` widget.
         *
         * A single `GtkEntryBuffer` object can be shared by multiple widgets
         * which will then share the same text content, but not the cursor
         * position, visibility attributes, icon etc.
         *
         * `GtkEntryBuffer` may be derived from. Such a derived class might allow
         * text to be stored in an alternate location, such as non-pageable memory,
         * useful in the case of important passwords. Or a derived class could
         * integrate with an application’s concept of undo/redo.
         */
        class EntryBuffer extends GObject.Object {
            static $gtype: GObject.GType<EntryBuffer>;

            // Properties

            /**
             * The length (in characters) of the text in buffer.
             */
            get length(): number;
            /**
             * The maximum length (in characters) of the text in the buffer.
             */
            get max_length(): number;
            set max_length(val: number);
            /**
             * The maximum length (in characters) of the text in the buffer.
             */
            get maxLength(): number;
            set maxLength(val: number);
            /**
             * The contents of the buffer.
             */
            get text(): string;
            set text(val: string);

            // Constructors

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

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

            static ['new'](initial_chars: string | null, n_initial_chars: number): EntryBuffer;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(
                signal: 'deleted-text',
                callback: (_source: this, position: number, n_chars: number) => void,
            ): number;
            connect_after(
                signal: 'deleted-text',
                callback: (_source: this, position: number, n_chars: number) => void,
            ): number;
            emit(signal: 'deleted-text', position: number, n_chars: number): void;
            connect(
                signal: 'inserted-text',
                callback: (_source: this, position: number, chars: string, n_chars: number) => void,
            ): number;
            connect_after(
                signal: 'inserted-text',
                callback: (_source: this, position: number, chars: string, n_chars: number) => void,
            ): number;
            emit(signal: 'inserted-text', position: number, chars: string, n_chars: number): void;

            // Virtual methods

            /**
             * Deletes a sequence of characters from the buffer.
             *
             * `n_chars` characters are deleted starting at `position`.
             * If `n_chars` is negative, then all characters until the
             * end of the text are deleted.
             *
             * If `position` or `n_chars` are out of bounds, then they
             * are coerced to sane values.
             *
             * Note that the positions are specified in characters,
             * not bytes.
             * @param position position at which to delete text
             * @param n_chars number of characters to delete
             */
            vfunc_delete_text(position: number, n_chars: number): number;
            vfunc_deleted_text(position: number, n_chars: number): void;
            /**
             * Retrieves the length in characters of the buffer.
             */
            vfunc_get_length(): number;
            vfunc_get_text(n_bytes: number): string;
            /**
             * Inserts `n_chars` characters of `chars` into the contents of the
             * buffer, at position `position`.
             *
             * If `n_chars` is negative, then characters from chars will be inserted
             * until a null-terminator is found. If `position` or `n_chars` are out of
             * bounds, or the maximum buffer text length is exceeded, then they are
             * coerced to sane values.
             *
             * Note that the position and length are in characters, not in bytes.
             * @param position the position at which to insert text.
             * @param chars the text to insert into the buffer.
             * @param n_chars the length of the text in characters, or -1
             */
            vfunc_insert_text(position: number, chars: string, n_chars: number): number;
            vfunc_inserted_text(position: number, chars: string, n_chars: number): void;

            // Methods

            /**
             * Deletes a sequence of characters from the buffer.
             *
             * `n_chars` characters are deleted starting at `position`.
             * If `n_chars` is negative, then all characters until the
             * end of the text are deleted.
             *
             * If `position` or `n_chars` are out of bounds, then they
             * are coerced to sane values.
             *
             * Note that the positions are specified in characters,
             * not bytes.
             * @param position position at which to delete text
             * @param n_chars number of characters to delete
             * @returns The number of characters deleted.
             */
            delete_text(position: number, n_chars: number): number;
            /**
             * Used when subclassing `GtkEntryBuffer`.
             * @param position position at which text was deleted
             * @param n_chars number of characters deleted
             */
            emit_deleted_text(position: number, n_chars: number): void;
            /**
             * Used when subclassing `GtkEntryBuffer`.
             * @param position position at which text was inserted
             * @param chars text that was inserted
             * @param n_chars number of characters inserted
             */
            emit_inserted_text(position: number, chars: string, n_chars: number): void;
            /**
             * Retrieves the length in bytes of the buffer.
             *
             * See [method`Gtk`.EntryBuffer.get_length].
             * @returns The byte length of the buffer.
             */
            get_bytes(): number;
            /**
             * Retrieves the length in characters of the buffer.
             * @returns The number of characters in the buffer.
             */
            get_length(): number;
            /**
             * Retrieves the maximum allowed length of the text in `buffer`.
             * @returns the maximum allowed number of characters   in `GtkEntryBuffer`, or 0 if there is no maximum.
             */
            get_max_length(): number;
            /**
             * Retrieves the contents of the buffer.
             *
             * The memory pointer returned by this call will not change
             * unless this object emits a signal, or is finalized.
             * @returns a pointer to the contents of the widget as a   string. This string points to internally allocated storage   in the buffer and must not be freed, modified or stored.
             */
            get_text(): string;
            /**
             * Inserts `n_chars` characters of `chars` into the contents of the
             * buffer, at position `position`.
             *
             * If `n_chars` is negative, then characters from chars will be inserted
             * until a null-terminator is found. If `position` or `n_chars` are out of
             * bounds, or the maximum buffer text length is exceeded, then they are
             * coerced to sane values.
             *
             * Note that the position and length are in characters, not in bytes.
             * @param position the position at which to insert text.
             * @param chars the text to insert into the buffer.
             * @param n_chars the length of the text in characters, or -1
             * @returns The number of characters actually inserted.
             */
            insert_text(position: number, chars: string, n_chars: number): number;
            /**
             * Sets the maximum allowed length of the contents of the buffer.
             *
             * If the current contents are longer than the given length, then
             * they will be truncated to fit.
             * @param max_length the maximum length of the entry buffer, or 0 for no maximum.   (other than the maximum length of entries.) The value passed in will   be clamped to the range 0-65536.
             */
            set_max_length(max_length: number): void;
            /**
             * Sets the text in the buffer.
             *
             * This is roughly equivalent to calling
             * [method`Gtk`.EntryBuffer.delete_text] and
             * [method`Gtk`.EntryBuffer.insert_text].
             *
             * Note that `n_chars` is in characters, not in bytes.
             * @param chars the new text
             * @param n_chars the number of characters in @text, or -1
             */
            set_text(chars: string, n_chars: number): void;
        }

        namespace EntryCompletion {
            // Signal callback interfaces

            interface CursorOnMatch {
                (model: TreeModel, iter: TreeIter): boolean;
            }

            interface InsertPrefix {
                (prefix: string): boolean;
            }

            interface MatchSelected {
                (model: TreeModel, iter: TreeIter): boolean;
            }

            interface NoMatches {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends GObject.Object.ConstructorProps,
                    Buildable.ConstructorProps,
                    CellLayout.ConstructorProps {
                cell_area: CellArea;
                cellArea: CellArea;
                inline_completion: boolean;
                inlineCompletion: boolean;
                inline_selection: boolean;
                inlineSelection: boolean;
                minimum_key_length: number;
                minimumKeyLength: number;
                model: TreeModel;
                popup_completion: boolean;
                popupCompletion: boolean;
                popup_set_width: boolean;
                popupSetWidth: boolean;
                popup_single_match: boolean;
                popupSingleMatch: boolean;
                text_column: number;
                textColumn: number;
            }
        }

        /**
         * `GtkEntryCompletion` is an auxiliary object to provide completion functionality
         * for `GtkEntry`.
         *
         * It implements the [iface`Gtk`.CellLayout] interface, to allow the user
         * to add extra cells to the `GtkTreeView` with completion matches.
         *
         * “Completion functionality” means that when the user modifies the text
         * in the entry, `GtkEntryCompletion` checks which rows in the model match
         * the current content of the entry, and displays a list of matches.
         * By default, the matching is done by comparing the entry text
         * case-insensitively against the text column of the model (see
         * [method`Gtk`.EntryCompletion.set_text_column]), but this can be overridden
         * with a custom match function (see [method`Gtk`.EntryCompletion.set_match_func]).
         *
         * When the user selects a completion, the content of the entry is
         * updated. By default, the content of the entry is replaced by the
         * text column of the model, but this can be overridden by connecting
         * to the [signal`Gtk`.EntryCompletion::match-selected] signal and updating the
         * entry in the signal handler. Note that you should return %TRUE from
         * the signal handler to suppress the default behaviour.
         *
         * To add completion functionality to an entry, use
         * [method`Gtk`.Entry.set_completion].
         *
         * `GtkEntryCompletion` uses a [class`Gtk`.TreeModelFilter] model to
         * represent the subset of the entire model that is currently matching.
         * While the `GtkEntryCompletion` signals
         * [signal`Gtk`.EntryCompletion::match-selected] and
         * [signal`Gtk`.EntryCompletion::cursor-on-match] take the original model
         * and an iter pointing to that model as arguments, other callbacks and
         * signals (such as `GtkCellLayoutDataFunc` or
         * [signal`Gtk`.CellArea::apply-attributes)]
         * will generally take the filter model as argument. As long as you are
         * only calling [method`Gtk`.TreeModel.get], this will make no difference to
         * you. If for some reason, you need the original model, use
         * [method`Gtk`.TreeModelFilter.get_model]. Don’t forget to use
         * [method`Gtk`.TreeModelFilter.convert_iter_to_child_iter] to obtain a
         * matching iter.
         */
        class EntryCompletion extends GObject.Object implements Buildable, CellLayout {
            static $gtype: GObject.GType<EntryCompletion>;

            // Properties

            /**
             * The `GtkCellArea` used to layout cell renderers in the treeview column.
             *
             * If no area is specified when creating the entry completion with
             * [ctor`Gtk`.EntryCompletion.new_with_area], a horizontally oriented
             * [class`Gtk`.CellAreaBox] will be used.
             */
            get cell_area(): CellArea;
            /**
             * The `GtkCellArea` used to layout cell renderers in the treeview column.
             *
             * If no area is specified when creating the entry completion with
             * [ctor`Gtk`.EntryCompletion.new_with_area], a horizontally oriented
             * [class`Gtk`.CellAreaBox] will be used.
             */
            get cellArea(): CellArea;
            /**
             * Determines whether the common prefix of the possible completions
             * should be inserted automatically in the entry.
             *
             * Note that this requires text-column to be set, even if you are
             * using a custom match function.
             */
            get inline_completion(): boolean;
            set inline_completion(val: boolean);
            /**
             * Determines whether the common prefix of the possible completions
             * should be inserted automatically in the entry.
             *
             * Note that this requires text-column to be set, even if you are
             * using a custom match function.
             */
            get inlineCompletion(): boolean;
            set inlineCompletion(val: boolean);
            /**
             * Determines whether the possible completions on the popup
             * will appear in the entry as you navigate through them.
             */
            get inline_selection(): boolean;
            set inline_selection(val: boolean);
            /**
             * Determines whether the possible completions on the popup
             * will appear in the entry as you navigate through them.
             */
            get inlineSelection(): boolean;
            set inlineSelection(val: boolean);
            /**
             * The minimum key length as set for completion.
             */
            get minimum_key_length(): number;
            set minimum_key_length(val: number);
            /**
             * The minimum key length as set for completion.
             */
            get minimumKeyLength(): number;
            set minimumKeyLength(val: number);
            /**
             * The model used as data source.
             */
            get model(): TreeModel;
            set model(val: TreeModel);
            /**
             * Determines whether the possible completions should be
             * shown in a popup window.
             */
            get popup_completion(): boolean;
            set popup_completion(val: boolean);
            /**
             * Determines whether the possible completions should be
             * shown in a popup window.
             */
            get popupCompletion(): boolean;
            set popupCompletion(val: boolean);
            /**
             * Determines whether the completions popup window will be
             * resized to the width of the entry.
             */
            get popup_set_width(): boolean;
            set popup_set_width(val: boolean);
            /**
             * Determines whether the completions popup window will be
             * resized to the width of the entry.
             */
            get popupSetWidth(): boolean;
            set popupSetWidth(val: boolean);
            /**
             * Determines whether the completions popup window will shown
             * for a single possible completion.
             *
             * You probably want to set this to %FALSE if you are using
             * [property`Gtk`.EntryCompletion:inline-completion].
             */
            get popup_single_match(): boolean;
            set popup_single_match(val: boolean);
            /**
             * Determines whether the completions popup window will shown
             * for a single possible completion.
             *
             * You probably want to set this to %FALSE if you are using
             * [property`Gtk`.EntryCompletion:inline-completion].
             */
            get popupSingleMatch(): boolean;
            set popupSingleMatch(val: boolean);
            /**
             * The column of the model containing the strings.
             *
             * Note that the strings must be UTF-8.
             */
            get text_column(): number;
            set text_column(val: number);
            /**
             * The column of the model containing the strings.
             *
             * Note that the strings must be UTF-8.
             */
            get textColumn(): number;
            set textColumn(val: number);

            // Constructors

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

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

            static ['new'](): EntryCompletion;

            static new_with_area(area: CellArea): EntryCompletion;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(
                signal: 'cursor-on-match',
                callback: (_source: this, model: TreeModel, iter: TreeIter) => boolean,
            ): number;
            connect_after(
                signal: 'cursor-on-match',
                callback: (_source: this, model: TreeModel, iter: TreeIter) => boolean,
            ): number;
            emit(signal: 'cursor-on-match', model: TreeModel, iter: TreeIter): void;
            connect(signal: 'insert-prefix', callback: (_source: this, prefix: string) => boolean): number;
            connect_after(signal: 'insert-prefix', callback: (_source: this, prefix: string) => boolean): number;
            emit(signal: 'insert-prefix', prefix: string): void;
            connect(
                signal: 'match-selected',
                callback: (_source: this, model: TreeModel, iter: TreeIter) => boolean,
            ): number;
            connect_after(
                signal: 'match-selected',
                callback: (_source: this, model: TreeModel, iter: TreeIter) => boolean,
            ): number;
            emit(signal: 'match-selected', model: TreeModel, iter: TreeIter): void;
            connect(signal: 'no-matches', callback: (_source: this) => void): number;
            connect_after(signal: 'no-matches', callback: (_source: this) => void): number;
            emit(signal: 'no-matches'): void;

            // Methods

            /**
             * Requests a completion operation, or in other words a refiltering of the
             * current list with completions, using the current key.
             *
             * The completion list view will be updated accordingly.
             */
            complete(): void;
            /**
             * Computes the common prefix that is shared by all rows in `completion`
             * that start with `key`.
             *
             * If no row matches `key,` %NULL will be returned.
             * Note that a text column must have been set for this function to work,
             * see [method`Gtk`.EntryCompletion.set_text_column] for details.
             * @param key The text to complete for
             * @returns The common prefix all rows   starting with @key
             */
            compute_prefix(key: string): string | null;
            /**
             * Get the original text entered by the user that triggered
             * the completion or %NULL if there’s no completion ongoing.
             * @returns the prefix for the current completion
             */
            get_completion_prefix(): string | null;
            /**
             * Gets the entry `completion` has been attached to.
             * @returns The entry @completion has been attached to
             */
            get_entry(): Widget;
            /**
             * Returns whether the common prefix of the possible completions should
             * be automatically inserted in the entry.
             * @returns %TRUE if inline completion is turned on
             */
            get_inline_completion(): boolean;
            /**
             * Returns %TRUE if inline-selection mode is turned on.
             * @returns %TRUE if inline-selection mode is on
             */
            get_inline_selection(): boolean;
            /**
             * Returns the minimum key length as set for `completion`.
             * @returns The currently used minimum key length
             */
            get_minimum_key_length(): number;
            /**
             * Returns the model the `GtkEntryCompletion` is using as data source.
             *
             * Returns %NULL if the model is unset.
             * @returns A `GtkTreeModel`
             */
            get_model(): TreeModel | null;
            /**
             * Returns whether the completions should be presented in a popup window.
             * @returns %TRUE if popup completion is turned on
             */
            get_popup_completion(): boolean;
            /**
             * Returns whether the completion popup window will be resized to the
             * width of the entry.
             * @returns %TRUE if the popup window will be resized to the width of   the entry
             */
            get_popup_set_width(): boolean;
            /**
             * Returns whether the completion popup window will appear even if there is
             * only a single match.
             * @returns %TRUE if the popup window will appear regardless of the    number of matches
             */
            get_popup_single_match(): boolean;
            /**
             * Returns the column in the model of `completion` to get strings from.
             * @returns the column containing the strings
             */
            get_text_column(): number;
            /**
             * Requests a prefix insertion.
             */
            insert_prefix(): void;
            /**
             * Sets whether the common prefix of the possible completions should
             * be automatically inserted in the entry.
             * @param inline_completion %TRUE to do inline completion
             */
            set_inline_completion(inline_completion: boolean): void;
            /**
             * Sets whether it is possible to cycle through the possible completions
             * inside the entry.
             * @param inline_selection %TRUE to do inline selection
             */
            set_inline_selection(inline_selection: boolean): void;
            /**
             * Sets the match function for `completion` to be `func`.
             *
             * The match function is used to determine if a row should or
             * should not be in the completion list.
             * @param func the `GtkEntryCompletion`MatchFunc to use
             */
            set_match_func(func: EntryCompletionMatchFunc): void;
            /**
             * Requires the length of the search key for `completion` to be at least
             * `length`.
             *
             * This is useful for long lists, where completing using a small
             * key takes a lot of time and will come up with meaningless results anyway
             * (ie, a too large dataset).
             * @param length the minimum length of the key in order to start completing
             */
            set_minimum_key_length(length: number): void;
            /**
             * Sets the model for a `GtkEntryCompletion`.
             *
             * If `completion` already has a model set, it will remove it
             * before setting the new model. If model is %NULL, then it
             * will unset the model.
             * @param model the `GtkTreeModel`
             */
            set_model(model?: TreeModel | null): void;
            /**
             * Sets whether the completions should be presented in a popup window.
             * @param popup_completion %TRUE to do popup completion
             */
            set_popup_completion(popup_completion: boolean): void;
            /**
             * Sets whether the completion popup window will be resized to be the same
             * width as the entry.
             * @param popup_set_width %TRUE to make the width of the popup the same as the entry
             */
            set_popup_set_width(popup_set_width: boolean): void;
            /**
             * Sets whether the completion popup window will appear even if there is
             * only a single match.
             *
             * You may want to set this to %FALSE if you
             * are using [property`Gtk`.EntryCompletion:inline-completion].
             * @param popup_single_match %TRUE if the popup should appear even for a single match
             */
            set_popup_single_match(popup_single_match: boolean): void;
            /**
             * Convenience function for setting up the most used case of this code: a
             * completion list with just strings.
             *
             * This function will set up `completion`
             * to have a list displaying all (and just) strings in the completion list,
             * and to get those strings from `column` in the model of `completion`.
             *
             * This functions creates and adds a `GtkCellRendererText` for the selected
             * column. If you need to set the text column, but don't want the cell
             * renderer, use g_object_set() to set the
             * [property`Gtk`.EntryCompletion:text-column] property directly.
             * @param column the column in the model of @completion to get strings from
             */
            set_text_column(column: number): void;

            // Inherited methods
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Adds an attribute mapping to the list in `cell_layout`.
             *
             * The `column` is the column of the model to get a value from, and the
             * `attribute` is the property on `cell` to be set from that value. So for
             * example if column 2 of the model contains strings, you could have the
             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
             * In this context "attribute" and "property" are used interchangeably.
             * @param cell a `GtkCellRenderer`
             * @param attribute a property on the renderer
             * @param column the column position on the model to get the attribute from
             */
            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
            /**
             * Unsets all the mappings on all renderers on `cell_layout` and
             * removes all renderers from `cell_layout`.
             */
            clear(): void;
            /**
             * Clears all existing attributes previously set with
             * gtk_cell_layout_set_attributes().
             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
             */
            clear_attributes(cell: CellRenderer): void;
            /**
             * Returns the underlying `GtkCellArea` which might be `cell_layout`
             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
             * is used by `cell_layout`.
             * @returns the cell area used by @cell_layout
             */
            get_area(): CellArea | null;
            /**
             * Returns the cell renderers which have been added to `cell_layout`.
             * @returns a list of cell renderers. The list, but not the renderers has   been newly allocated and should be freed with g_list_free()   when no longer needed.
             */
            get_cells(): CellRenderer[];
            /**
             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
             * `cell` is allocated no more space than it needs. Any unused space is
             * divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            pack_end(cell: CellRenderer, expand: boolean): void;
            /**
             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
             * then the `cell` is allocated no more space than it needs. Any unused space
             * is divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            pack_start(cell: CellRenderer, expand: boolean): void;
            /**
             * Re-inserts `cell` at `position`.
             *
             * Note that `cell` has already to be packed into `cell_layout`
             * for this to function properly.
             * @param cell a `GtkCellRenderer` to reorder
             * @param position new position to insert @cell at
             */
            reorder(cell: CellRenderer, position: number): void;
            /**
             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
             *
             * This function is used instead of the standard attributes mapping
             * for setting the column value, and should set the value of `cell_layout’`s
             * cell renderer(s) as appropriate.
             *
             * `func` may be %NULL to remove a previously set function.
             * @param cell a `GtkCellRenderer`
             * @param func the `GtkCellLayout`DataFunc to use
             */
            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
            /**
             * Adds an attribute mapping to the list in `cell_layout`.
             *
             * The `column` is the column of the model to get a value from, and the
             * `attribute` is the property on `cell` to be set from that value. So for
             * example if column 2 of the model contains strings, you could have the
             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
             * In this context "attribute" and "property" are used interchangeably.
             * @param cell a `GtkCellRenderer`
             * @param attribute a property on the renderer
             * @param column the column position on the model to get the attribute from
             */
            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
            /**
             * Unsets all the mappings on all renderers on `cell_layout` and
             * removes all renderers from `cell_layout`.
             */
            vfunc_clear(): void;
            /**
             * Clears all existing attributes previously set with
             * gtk_cell_layout_set_attributes().
             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
             */
            vfunc_clear_attributes(cell: CellRenderer): void;
            /**
             * Returns the underlying `GtkCellArea` which might be `cell_layout`
             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
             * is used by `cell_layout`.
             */
            vfunc_get_area(): CellArea | null;
            /**
             * Returns the cell renderers which have been added to `cell_layout`.
             */
            vfunc_get_cells(): CellRenderer[];
            /**
             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
             * `cell` is allocated no more space than it needs. Any unused space is
             * divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
            /**
             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
             * then the `cell` is allocated no more space than it needs. Any unused space
             * is divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
            /**
             * Re-inserts `cell` at `position`.
             *
             * Note that `cell` has already to be packed into `cell_layout`
             * for this to function properly.
             * @param cell a `GtkCellRenderer` to reorder
             * @param position new position to insert @cell at
             */
            vfunc_reorder(cell: CellRenderer, position: number): void;
            /**
             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
             *
             * This function is used instead of the standard attributes mapping
             * for setting the column value, and should set the value of `cell_layout’`s
             * cell renderer(s) as appropriate.
             *
             * `func` may be %NULL to remove a previously set function.
             * @param cell a `GtkCellRenderer`
             * @param func the `GtkCellLayout`DataFunc to use
             */
            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace EventController {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                name: string;
                propagation_limit: PropagationLimit;
                propagationLimit: PropagationLimit;
                propagation_phase: PropagationPhase;
                propagationPhase: PropagationPhase;
                widget: Widget;
            }
        }

        /**
         * `GtkEventController` is the base class for event controllers.
         *
         * These are ancillary objects associated to widgets, which react
         * to `GdkEvents`, and possibly trigger actions as a consequence.
         *
         * Event controllers are added to a widget with
         * [method`Gtk`.Widget.add_controller]. It is rarely necessary to
         * explicitly remove a controller with [method`Gtk`.Widget.remove_controller].
         *
         * See the chapter on [input handling](input-handling.html) for
         * an overview of the basic concepts, such as the capture and bubble
         * phases of event propagation.
         */
        abstract class EventController extends GObject.Object {
            static $gtype: GObject.GType<EventController>;

            // Properties

            /**
             * The name for this controller, typically used for debugging purposes.
             */
            get name(): string;
            set name(val: string);
            /**
             * The limit for which events this controller will handle.
             */
            get propagation_limit(): PropagationLimit;
            set propagation_limit(val: PropagationLimit);
            /**
             * The limit for which events this controller will handle.
             */
            get propagationLimit(): PropagationLimit;
            set propagationLimit(val: PropagationLimit);
            /**
             * The propagation phase at which this controller will handle events.
             */
            get propagation_phase(): PropagationPhase;
            set propagation_phase(val: PropagationPhase);
            /**
             * The propagation phase at which this controller will handle events.
             */
            get propagationPhase(): PropagationPhase;
            set propagationPhase(val: PropagationPhase);
            /**
             * The widget receiving the `GdkEvents` that the controller will handle.
             */
            get widget(): Widget;

            // Constructors

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

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

            // Methods

            /**
             * Returns the event that is currently being handled by the controller.
             *
             * At other times, %NULL is returned.
             * @returns the event that is currently   handled by @controller
             */
            get_current_event(): Gdk.Event | null;
            /**
             * Returns the device of the event that is currently being
             * handled by the controller.
             *
             * At other times, %NULL is returned.
             * @returns device of the event is   currently handled by @controller
             */
            get_current_event_device(): Gdk.Device | null;
            /**
             * Returns the modifier state of the event that is currently being
             * handled by the controller.
             *
             * At other times, 0 is returned.
             * @returns modifier state of the event is currently handled by @controller
             */
            get_current_event_state(): Gdk.ModifierType;
            /**
             * Returns the timestamp of the event that is currently being
             * handled by the controller.
             *
             * At other times, 0 is returned.
             * @returns timestamp of the event is currently handled by @controller
             */
            get_current_event_time(): number;
            /**
             * Gets the name of `controller`.
             * @returns The controller name
             */
            get_name(): string | null;
            /**
             * Gets the propagation limit of the event controller.
             * @returns the propagation limit
             */
            get_propagation_limit(): PropagationLimit;
            /**
             * Gets the propagation phase at which `controller` handles events.
             * @returns the propagation phase
             */
            get_propagation_phase(): PropagationPhase;
            /**
             * Returns the `GtkWidget` this controller relates to.
             * @returns a `GtkWidget`
             */
            get_widget(): Widget | null;
            /**
             * Resets the `controller` to a clean state.
             */
            reset(): void;
            /**
             * Sets a name on the controller that can be used for debugging.
             * @param name a name for @controller
             */
            set_name(name?: string | null): void;
            /**
             * Sets the event propagation limit on the event controller.
             *
             * If the limit is set to %GTK_LIMIT_SAME_NATIVE, the controller
             * won't handle events that are targeted at widgets on a different
             * surface, such as popovers.
             * @param limit the propagation limit
             */
            set_propagation_limit(limit: PropagationLimit | null): void;
            /**
             * Sets the propagation phase at which a controller handles events.
             *
             * If `phase` is %GTK_PHASE_NONE, no automatic event handling will be
             * performed, but other additional gesture maintenance will.
             * @param phase a propagation phase
             */
            set_propagation_phase(phase: PropagationPhase | null): void;
            /**
             * Sets a name on the controller that can be used for debugging.
             * @param name a name for @controller, must be a static string
             */
            set_static_name(name?: string | null): void;
        }

        namespace EventControllerFocus {
            // Signal callback interfaces

            interface Enter {
                (): void;
            }

            interface Leave {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends EventController.ConstructorProps {
                contains_focus: boolean;
                containsFocus: boolean;
                is_focus: boolean;
                isFocus: boolean;
            }
        }

        /**
         * `GtkEventControllerFocus` is an event controller to keep track of
         * keyboard focus.
         *
         * The event controller offers [signal`Gtk`.EventControllerFocus::enter]
         * and [signal`Gtk`.EventControllerFocus::leave] signals, as well as
         * [property`Gtk`.EventControllerFocus:is-focus] and
         * [property`Gtk`.EventControllerFocus:contains-focus] properties
         * which are updated to reflect focus changes inside the widget hierarchy
         * that is rooted at the controllers widget.
         */
        class EventControllerFocus extends EventController {
            static $gtype: GObject.GType<EventControllerFocus>;

            // Properties

            /**
             * %TRUE if focus is contained in the controllers widget.
             *
             * See [property`Gtk`.EventControllerFocus:is-focus] for whether
             * the focus is in the widget itself or inside a descendent.
             *
             * When handling focus events, this property is updated
             * before [signal`Gtk`.EventControllerFocus::enter] or
             * [signal`Gtk`.EventControllerFocus::leave] are emitted.
             */
            get contains_focus(): boolean;
            /**
             * %TRUE if focus is contained in the controllers widget.
             *
             * See [property`Gtk`.EventControllerFocus:is-focus] for whether
             * the focus is in the widget itself or inside a descendent.
             *
             * When handling focus events, this property is updated
             * before [signal`Gtk`.EventControllerFocus::enter] or
             * [signal`Gtk`.EventControllerFocus::leave] are emitted.
             */
            get containsFocus(): boolean;
            /**
             * %TRUE if focus is in the controllers widget itself,
             * as opposed to in a descendent widget.
             *
             * See also [property`Gtk`.EventControllerFocus:contains-focus].
             *
             * When handling focus events, this property is updated
             * before [signal`Gtk`.EventControllerFocus::enter] or
             * [signal`Gtk`.EventControllerFocus::leave] are emitted.
             */
            get is_focus(): boolean;
            /**
             * %TRUE if focus is in the controllers widget itself,
             * as opposed to in a descendent widget.
             *
             * See also [property`Gtk`.EventControllerFocus:contains-focus].
             *
             * When handling focus events, this property is updated
             * before [signal`Gtk`.EventControllerFocus::enter] or
             * [signal`Gtk`.EventControllerFocus::leave] are emitted.
             */
            get isFocus(): boolean;

            // Constructors

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

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

            static ['new'](): EventControllerFocus;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'enter', callback: (_source: this) => void): number;
            connect_after(signal: 'enter', callback: (_source: this) => void): number;
            emit(signal: 'enter'): void;
            connect(signal: 'leave', callback: (_source: this) => void): number;
            connect_after(signal: 'leave', callback: (_source: this) => void): number;
            emit(signal: 'leave'): void;
        }

        namespace EventControllerKey {
            // Signal callback interfaces

            interface ImUpdate {
                (): void;
            }

            interface KeyPressed {
                (keyval: number, keycode: number, state: Gdk.ModifierType): boolean;
            }

            interface KeyReleased {
                (keyval: number, keycode: number, state: Gdk.ModifierType): void;
            }

            interface Modifiers {
                (state: Gdk.ModifierType): boolean;
            }

            // Constructor properties interface

            interface ConstructorProps extends EventController.ConstructorProps {}
        }

        /**
         * `GtkEventControllerKey` is an event controller that provides access
         * to key events.
         */
        class EventControllerKey extends EventController {
            static $gtype: GObject.GType<EventControllerKey>;

            // Constructors

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

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

            static ['new'](): EventControllerKey;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'im-update', callback: (_source: this) => void): number;
            connect_after(signal: 'im-update', callback: (_source: this) => void): number;
            emit(signal: 'im-update'): void;
            connect(
                signal: 'key-pressed',
                callback: (_source: this, keyval: number, keycode: number, state: Gdk.ModifierType) => boolean,
            ): number;
            connect_after(
                signal: 'key-pressed',
                callback: (_source: this, keyval: number, keycode: number, state: Gdk.ModifierType) => boolean,
            ): number;
            emit(signal: 'key-pressed', keyval: number, keycode: number, state: Gdk.ModifierType): void;
            connect(
                signal: 'key-released',
                callback: (_source: this, keyval: number, keycode: number, state: Gdk.ModifierType) => void,
            ): number;
            connect_after(
                signal: 'key-released',
                callback: (_source: this, keyval: number, keycode: number, state: Gdk.ModifierType) => void,
            ): number;
            emit(signal: 'key-released', keyval: number, keycode: number, state: Gdk.ModifierType): void;
            connect(signal: 'modifiers', callback: (_source: this, state: Gdk.ModifierType) => boolean): number;
            connect_after(signal: 'modifiers', callback: (_source: this, state: Gdk.ModifierType) => boolean): number;
            emit(signal: 'modifiers', state: Gdk.ModifierType): void;

            // Methods

            /**
             * Forwards the current event of this `controller` to a `widget`.
             *
             * This function can only be used in handlers for the
             * [signal`Gtk`.EventControllerKey::key-pressed],
             * [signal`Gtk`.EventControllerKey::key-released]
             * or [signal`Gtk`.EventControllerKey::modifiers] signals.
             * @param widget a `GtkWidget`
             * @returns whether the @widget handled the event
             */
            forward(widget: Widget): boolean;
            /**
             * Gets the key group of the current event of this `controller`.
             *
             * See [method`Gdk`.KeyEvent.get_layout].
             * @returns the key group
             */
            get_group(): number;
            /**
             * Gets the input method context of the key `controller`.
             * @returns the `GtkIMContext`
             */
            get_im_context(): IMContext | null;
            /**
             * Sets the input method context of the key `controller`.
             * @param im_context a `GtkIMContext`
             */
            set_im_context(im_context?: IMContext | null): void;
        }

        namespace EventControllerLegacy {
            // Signal callback interfaces

            interface Event {
                (event: Gdk.Event): boolean;
            }

            // Constructor properties interface

            interface ConstructorProps extends EventController.ConstructorProps {}
        }

        /**
         * `GtkEventControllerLegacy` is an event controller that provides raw
         * access to the event stream.
         *
         * It should only be used as a last resort if none of the other event
         * controllers or gestures do the job.
         */
        class EventControllerLegacy extends EventController {
            static $gtype: GObject.GType<EventControllerLegacy>;

            // Constructors

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

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

            static ['new'](): EventControllerLegacy;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'event', callback: (_source: this, event: Gdk.Event) => boolean): number;
            connect_after(signal: 'event', callback: (_source: this, event: Gdk.Event) => boolean): number;
            emit(signal: 'event', event: Gdk.Event): void;
        }

        namespace EventControllerMotion {
            // Signal callback interfaces

            interface Enter {
                (x: number, y: number): void;
            }

            interface Leave {
                (): void;
            }

            interface Motion {
                (x: number, y: number): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends EventController.ConstructorProps {
                contains_pointer: boolean;
                containsPointer: boolean;
                is_pointer: boolean;
                isPointer: boolean;
            }
        }

        /**
         * `GtkEventControllerMotion` is an event controller tracking the pointer
         * position.
         *
         * The event controller offers [signal`Gtk`.EventControllerMotion::enter]
         * and [signal`Gtk`.EventControllerMotion::leave] signals, as well as
         * [property`Gtk`.EventControllerMotion:is-pointer] and
         * [property`Gtk`.EventControllerMotion:contains-pointer] properties
         * which are updated to reflect changes in the pointer position as it
         * moves over the widget.
         */
        class EventControllerMotion extends EventController {
            static $gtype: GObject.GType<EventControllerMotion>;

            // Properties

            /**
             * Whether the pointer is in the controllers widget or a descendant.
             *
             * See also [property`Gtk`.EventControllerMotion:is-pointer].
             *
             * When handling crossing events, this property is updated
             * before [signal`Gtk`.EventControllerMotion::enter], but after
             * [signal`Gtk`.EventControllerMotion::leave] is emitted.
             */
            get contains_pointer(): boolean;
            /**
             * Whether the pointer is in the controllers widget or a descendant.
             *
             * See also [property`Gtk`.EventControllerMotion:is-pointer].
             *
             * When handling crossing events, this property is updated
             * before [signal`Gtk`.EventControllerMotion::enter], but after
             * [signal`Gtk`.EventControllerMotion::leave] is emitted.
             */
            get containsPointer(): boolean;
            /**
             * Whether the pointer is in the controllers widget itself,
             * as opposed to in a descendent widget.
             *
             * See also [property`Gtk`.EventControllerMotion:contains-pointer].
             *
             * When handling crossing events, this property is updated
             * before [signal`Gtk`.EventControllerMotion::enter], but after
             * [signal`Gtk`.EventControllerMotion::leave] is emitted.
             */
            get is_pointer(): boolean;
            /**
             * Whether the pointer is in the controllers widget itself,
             * as opposed to in a descendent widget.
             *
             * See also [property`Gtk`.EventControllerMotion:contains-pointer].
             *
             * When handling crossing events, this property is updated
             * before [signal`Gtk`.EventControllerMotion::enter], but after
             * [signal`Gtk`.EventControllerMotion::leave] is emitted.
             */
            get isPointer(): boolean;

            // Constructors

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

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

            static ['new'](): EventControllerMotion;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'enter', callback: (_source: this, x: number, y: number) => void): number;
            connect_after(signal: 'enter', callback: (_source: this, x: number, y: number) => void): number;
            emit(signal: 'enter', x: number, y: number): void;
            connect(signal: 'leave', callback: (_source: this) => void): number;
            connect_after(signal: 'leave', callback: (_source: this) => void): number;
            emit(signal: 'leave'): void;
            connect(signal: 'motion', callback: (_source: this, x: number, y: number) => void): number;
            connect_after(signal: 'motion', callback: (_source: this, x: number, y: number) => void): number;
            emit(signal: 'motion', x: number, y: number): void;
        }

        namespace EventControllerScroll {
            // Signal callback interfaces

            interface Decelerate {
                (vel_x: number, vel_y: number): void;
            }

            interface Scroll {
                (dx: number, dy: number): boolean;
            }

            interface ScrollBegin {
                (): void;
            }

            interface ScrollEnd {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends EventController.ConstructorProps {
                flags: EventControllerScrollFlags;
            }
        }

        /**
         * `GtkEventControllerScroll` is an event controller that handles scroll
         * events.
         *
         * It is capable of handling both discrete and continuous scroll
         * events from mice or touchpads, abstracting them both with the
         * [signal`Gtk`.EventControllerScroll::scroll] signal. Deltas in
         * the discrete case are multiples of 1.
         *
         * In the case of continuous scroll events, `GtkEventControllerScroll`
         * encloses all [signal`Gtk`.EventControllerScroll::scroll] emissions
         * between two [signal`Gtk`.EventControllerScroll::scroll-begin] and
         * [signal`Gtk`.EventControllerScroll::scroll-end] signals.
         *
         * The behavior of the event controller can be modified by the flags
         * given at creation time, or modified at a later point through
         * [method`Gtk`.EventControllerScroll.set_flags] (e.g. because the scrolling
         * conditions of the widget changed).
         *
         * The controller can be set up to emit motion for either/both vertical
         * and horizontal scroll events through %GTK_EVENT_CONTROLLER_SCROLL_VERTICAL,
         * %GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL and %GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES.
         * If any axis is disabled, the respective [signal`Gtk`.EventControllerScroll::scroll]
         * delta will be 0. Vertical scroll events will be translated to horizontal
         * motion for the devices incapable of horizontal scrolling.
         *
         * The event controller can also be forced to emit discrete events on all
         * devices through %GTK_EVENT_CONTROLLER_SCROLL_DISCRETE. This can be used
         * to implement discrete actions triggered through scroll events (e.g.
         * switching across combobox options).
         *
         * The %GTK_EVENT_CONTROLLER_SCROLL_KINETIC flag toggles the emission of the
         * [signal`Gtk`.EventControllerScroll::decelerate] signal, emitted at the end
         * of scrolling with two X/Y velocity arguments that are consistent with the
         * motion that was received.
         */
        class EventControllerScroll extends EventController {
            static $gtype: GObject.GType<EventControllerScroll>;

            // Properties

            /**
             * The flags affecting event controller behavior.
             */
            get flags(): EventControllerScrollFlags;
            set flags(val: EventControllerScrollFlags);

            // Constructors

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

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

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

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'decelerate', callback: (_source: this, vel_x: number, vel_y: number) => void): number;
            connect_after(
                signal: 'decelerate',
                callback: (_source: this, vel_x: number, vel_y: number) => void,
            ): number;
            emit(signal: 'decelerate', vel_x: number, vel_y: number): void;
            connect(signal: 'scroll', callback: (_source: this, dx: number, dy: number) => boolean): number;
            connect_after(signal: 'scroll', callback: (_source: this, dx: number, dy: number) => boolean): number;
            emit(signal: 'scroll', dx: number, dy: number): void;
            connect(signal: 'scroll-begin', callback: (_source: this) => void): number;
            connect_after(signal: 'scroll-begin', callback: (_source: this) => void): number;
            emit(signal: 'scroll-begin'): void;
            connect(signal: 'scroll-end', callback: (_source: this) => void): number;
            connect_after(signal: 'scroll-end', callback: (_source: this) => void): number;
            emit(signal: 'scroll-end'): void;

            // Methods

            /**
             * Gets the flags conditioning the scroll controller behavior.
             * @returns the controller flags.
             */
            get_flags(): EventControllerScrollFlags;
            /**
             * Gets the scroll unit of the last
             * [signal`Gtk`.EventControllerScroll::scroll] signal received.
             *
             * Always returns %GDK_SCROLL_UNIT_WHEEL if the
             * %GTK_EVENT_CONTROLLER_SCROLL_DISCRETE flag is set.
             * @returns the scroll unit.
             */
            get_unit(): Gdk.ScrollUnit;
            /**
             * Sets the flags conditioning scroll controller behavior.
             * @param flags flags affecting the controller behavior
             */
            set_flags(flags: EventControllerScrollFlags | null): void;
        }

        namespace EveryFilter {
            // Constructor properties interface

            interface ConstructorProps<A extends GObject.Object = GObject.Object>
                extends MultiFilter.ConstructorProps,
                    Gio.ListModel.ConstructorProps,
                    Buildable.ConstructorProps {}
        }

        /**
         * `GtkEveryFilter` matches an item when each of its filters matches.
         *
         * To add filters to a `GtkEveryFilter`, use [method`Gtk`.MultiFilter.append].
         */
        class EveryFilter<A extends GObject.Object = GObject.Object>
            extends MultiFilter
            implements Gio.ListModel<A>, Buildable
        {
            static $gtype: GObject.GType<EveryFilter>;

            // Constructors

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

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

            static ['new'](): EveryFilter;

            // Inherited methods
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             * @returns the #GType of the items contained in @list.
             */
            get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             * @returns the number of items in @list.
             */
            get_n_items(): number;
            /**
             * Get the item at `position`.
             *
             * If `position` is greater than the number of items in `list,` %NULL is
             * returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.
             *
             * This function is meant to be used by language bindings in place
             * of g_list_model_get_item().
             *
             * See also: g_list_model_get_n_items()
             * @param position the position of the item to fetch
             * @returns the object at @position.
             */
            get_item(position: number): A | null;
            /**
             * Emits the #GListModel::items-changed signal on `list`.
             *
             * This function should only be called by classes implementing
             * #GListModel. It has to be called after the internal representation
             * of `list` has been updated, because handlers connected to this signal
             * might query the new state of the list.
             *
             * Implementations must only make changes to the model (as visible to
             * its consumer) in places that will not cause problems for that
             * consumer.  For models that are driven directly by a write API (such
             * as #GListStore), changes can be reported in response to uses of that
             * API.  For models that represent remote data, changes should only be
             * made from a fresh mainloop dispatch.  It is particularly not
             * permitted to make changes in response to a call to the #GListModel
             * consumer API.
             *
             * Stated another way: in general, it is assumed that code making a
             * series of accesses to the model via the API, without returning to the
             * mainloop, and without calling other code, will continue to view the
             * same contents of the model.
             * @param position the position at which @list changed
             * @param removed the number of items removed
             * @param added the number of items added
             */
            items_changed(position: number, removed: number, added: number): void;
            /**
             * Get the item at `position`. If `position` is greater than the number of
             * items in `list,` %NULL is returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.  See g_list_model_get_n_items().
             *
             * The same #GObject instance may not appear more than once in a #GListModel.
             * @param position the position of the item to fetch
             */
            vfunc_get_item(position: number): A | null;
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             */
            vfunc_get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             */
            vfunc_get_n_items(): number;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Expander {
            // Signal callback interfaces

            interface Activate {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                child: Widget;
                expanded: boolean;
                label: string;
                label_widget: Widget;
                labelWidget: Widget;
                resize_toplevel: boolean;
                resizeToplevel: boolean;
                use_markup: boolean;
                useMarkup: boolean;
                use_underline: boolean;
                useUnderline: boolean;
            }
        }

        /**
         * `GtkExpander` allows the user to reveal its child by clicking
         * on an expander triangle.
         *
         * ![An example GtkExpander](expander.png)
         *
         * This is similar to the triangles used in a `GtkTreeView`.
         *
         * Normally you use an expander as you would use a frame; you create
         * the child widget and use [method`Gtk`.Expander.set_child] to add it
         * to the expander. When the expander is toggled, it will take care of
         * showing and hiding the child automatically.
         *
         * # Special Usage
         *
         * There are situations in which you may prefer to show and hide the
         * expanded widget yourself, such as when you want to actually create
         * the widget at expansion time. In this case, create a `GtkExpander`
         * but do not add a child to it. The expander widget has an
         * [property`Gtk`.Expander:expanded] property which can be used to
         * monitor its expansion state. You should watch this property with
         * a signal connection as follows:
         *
         * ```c
         * static void
         * expander_callback (GObject    *object,
         *                    GParamSpec *param_spec,
         *                    gpointer    user_data)
         * {
         *   GtkExpander *expander;
         *
         *   expander = GTK_EXPANDER (object);
         *
         *   if (gtk_expander_get_expanded (expander))
         *     {
         *       // Show or create widgets
         *     }
         *   else
         *     {
         *       // Hide or destroy widgets
         *     }
         * }
         *
         * static void
         * create_expander (void)
         * {
         *   GtkWidget *expander = gtk_expander_new_with_mnemonic ("_More Options");
         *   g_signal_connect (expander, "notify::expanded",
         *                     G_CALLBACK (expander_callback), NULL);
         *
         *   // ...
         * }
         * ```
         *
         * # GtkExpander as GtkBuildable
         *
         * The `GtkExpander` implementation of the `GtkBuildable` interface supports
         * placing a child in the label position by specifying “label” as the
         * “type” attribute of a `<child>` element. A normal content child can be
         * specified without specifying a `<child>` type attribute.
         *
         * An example of a UI definition fragment with GtkExpander:
         *
         * ```xml
         * <object class="GtkExpander">
         *   <child type="label">
         *     <object class="GtkLabel" id="expander-label"/>
         *   </child>
         *   <child>
         *     <object class="GtkEntry" id="expander-content"/>
         *   </child>
         * </object>
         * ```
         *
         * # CSS nodes
         *
         * ```
         * expander-widget
         * ╰── box
         *     ├── title
         *     │   ├── expander
         *     │   ╰── <label widget>
         *     ╰── <child>
         * ```
         *
         * `GtkExpander` has a main node `expander-widget`, and subnode `box` containing
         * the title and child widget. The box subnode `title` contains node `expander`,
         * i.e. the expand/collapse arrow; then the label widget if any. The arrow of an
         * expander that is showing its child gets the `:checked` pseudoclass set on it.
         *
         * # Accessibility
         *
         * `GtkExpander` uses the %GTK_ACCESSIBLE_ROLE_BUTTON role.
         */
        class Expander extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<Expander>;

            // Properties

            /**
             * The child widget.
             */
            get child(): Widget;
            set child(val: Widget);
            /**
             * Whether the expander has been opened to reveal the child.
             */
            get expanded(): boolean;
            set expanded(val: boolean);
            /**
             * The text of the expanders label.
             */
            get label(): string;
            set label(val: string);
            /**
             * A widget to display instead of the usual expander label.
             */
            get label_widget(): Widget;
            set label_widget(val: Widget);
            /**
             * A widget to display instead of the usual expander label.
             */
            get labelWidget(): Widget;
            set labelWidget(val: Widget);
            /**
             * When this property is %TRUE, the expander will resize the toplevel
             * widget containing the expander upon expanding and collapsing.
             */
            get resize_toplevel(): boolean;
            set resize_toplevel(val: boolean);
            /**
             * When this property is %TRUE, the expander will resize the toplevel
             * widget containing the expander upon expanding and collapsing.
             */
            get resizeToplevel(): boolean;
            set resizeToplevel(val: boolean);
            /**
             * Whether the text in the label is Pango markup.
             */
            get use_markup(): boolean;
            set use_markup(val: boolean);
            /**
             * Whether the text in the label is Pango markup.
             */
            get useMarkup(): boolean;
            set useMarkup(val: boolean);
            /**
             * Whether an underline in the text indicates a mnemonic.
             */
            get use_underline(): boolean;
            set use_underline(val: boolean);
            /**
             * Whether an underline in the text indicates a mnemonic.
             */
            get useUnderline(): boolean;
            set useUnderline(val: boolean);

            // Constructors

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

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

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

            static new_with_mnemonic(label?: string | null): Expander;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate', callback: (_source: this) => void): number;
            connect_after(signal: 'activate', callback: (_source: this) => void): number;
            emit(signal: 'activate'): void;

            // Methods

            /**
             * Gets the child widget of `expander`.
             * @returns the child widget of @expander
             */
            get_child(): Widget | null;
            /**
             * Queries a `GtkExpander` and returns its current state.
             *
             * Returns %TRUE if the child widget is revealed.
             * @returns the current state of the expander
             */
            get_expanded(): boolean;
            /**
             * Fetches the text from a label widget.
             *
             * This is including any embedded underlines indicating mnemonics and
             * Pango markup, as set by [method`Gtk`.Expander.set_label]. If the label
             * text has not been set the return value will be %NULL. This will be the
             * case if you create an empty button with gtk_button_new() to use as a
             * container.
             * @returns The text of the label widget. This string is owned   by the widget and must not be modified or freed.
             */
            get_label(): string | null;
            /**
             * Retrieves the label widget for the frame.
             * @returns the label widget
             */
            get_label_widget(): Widget | null;
            /**
             * Returns whether the expander will resize the toplevel widget
             * containing the expander upon resizing and collapsing.
             * @returns the “resize toplevel” setting.
             */
            get_resize_toplevel(): boolean;
            /**
             * Returns whether the label’s text is interpreted as Pango markup.
             * @returns %TRUE if the label’s text will be parsed for markup
             */
            get_use_markup(): boolean;
            /**
             * Returns whether an underline in the text indicates a mnemonic.
             * @returns %TRUE if an embedded underline in the expander   label indicates the mnemonic accelerator keys
             */
            get_use_underline(): boolean;
            /**
             * Sets the child widget of `expander`.
             * @param child the child widget
             */
            set_child(child?: Widget | null): void;
            /**
             * Sets the state of the expander.
             *
             * Set to %TRUE, if you want the child widget to be revealed,
             * and %FALSE if you want the child widget to be hidden.
             * @param expanded whether the child widget is revealed
             */
            set_expanded(expanded: boolean): void;
            /**
             * Sets the text of the label of the expander to `label`.
             *
             * This will also clear any previously set labels.
             * @param label a string
             */
            set_label(label?: string | null): void;
            /**
             * Set the label widget for the expander.
             *
             * This is the widget that will appear embedded alongside
             * the expander arrow.
             * @param label_widget the new label widget
             */
            set_label_widget(label_widget?: Widget | null): void;
            /**
             * Sets whether the expander will resize the toplevel widget
             * containing the expander upon resizing and collapsing.
             * @param resize_toplevel whether to resize the toplevel
             */
            set_resize_toplevel(resize_toplevel: boolean): void;
            /**
             * Sets whether the text of the label contains Pango markup.
             * @param use_markup %TRUE if the label’s text should be parsed for markup
             */
            set_use_markup(use_markup: boolean): void;
            /**
             * If true, an underline in the text indicates a mnemonic.
             * @param use_underline %TRUE if underlines in the text indicate mnemonics
             */
            set_use_underline(use_underline: boolean): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        /**
         * `GtkExpression` provides a way to describe references to values.
         *
         * An important aspect of expressions is that the value can be obtained
         * from a source that is several steps away. For example, an expression
         * may describe ‘the value of property A of `object1`, which is itself the
         * value of a property of `object2`’. And `object1` may not even exist yet
         * at the time that the expression is created. This is contrast to `GObject`
         * property bindings, which can only create direct connections between
         * the properties of two objects that must both exist for the duration
         * of the binding.
         *
         * An expression needs to be "evaluated" to obtain the value that it currently
         * refers to. An evaluation always happens in the context of a current object
         * called `this` (it mirrors the behavior of object-oriented languages),
         * which may or may not influence the result of the evaluation. Use
         * [method`Gtk`.Expression.evaluate] for evaluating an expression.
         *
         * Various methods for defining expressions exist, from simple constants via
         * [ctor`Gtk`.ConstantExpression.new] to looking up properties in a `GObject`
         * (even recursively) via [ctor`Gtk`.PropertyExpression.new] or providing
         * custom functions to transform and combine expressions via
         * [ctor`Gtk`.ClosureExpression.new].
         *
         * Here is an example of a complex expression:
         *
         * ```c
         *   color_expr = gtk_property_expression_new (GTK_TYPE_LIST_ITEM,
         *                                             NULL, "item");
         *   expression = gtk_property_expression_new (GTK_TYPE_COLOR,
         *                                             color_expr, "name");
         * ```
         *
         * when evaluated with `this` being a `GtkListItem`, it will obtain the
         * "item" property from the `GtkListItem`, and then obtain the "name" property
         * from the resulting object (which is assumed to be of type `GTK_TYPE_COLOR`).
         *
         * A more concise way to describe this would be
         *
         * ```
         *   this->item->name
         * ```
         *
         * The most likely place where you will encounter expressions is in the context
         * of list models and list widgets using them. For example, `GtkDropDown` is
         * evaluating a `GtkExpression` to obtain strings from the items in its model
         * that it can then use to match against the contents of its search entry.
         * `GtkStringFilter` is using a `GtkExpression` for similar reasons.
         *
         * By default, expressions are not paying attention to changes and evaluation is
         * just a snapshot of the current state at a given time. To get informed about
         * changes, an expression needs to be "watched" via a [struct`Gtk`.ExpressionWatch],
         * which will cause a callback to be called whenever the value of the expression may
         * have changed; [method`Gtk`.Expression.watch] starts watching an expression, and
         * [method`Gtk`.ExpressionWatch.unwatch] stops.
         *
         * Watches can be created for automatically updating the property of an object,
         * similar to GObject's `GBinding` mechanism, by using [method`Gtk`.Expression.bind].
         *
         * ## GtkExpression in GObject properties
         *
         * In order to use a `GtkExpression` as a `GObject` property, you must use the
         * [func`Gtk`.param_spec_expression] when creating a `GParamSpec` to install in the
         * `GObject` class being defined; for instance:
         *
         * ```c
         * obj_props[PROP_EXPRESSION] =
         *   gtk_param_spec_expression ("expression",
         *                              "Expression",
         *                              "The expression used by the widget",
         *                              G_PARAM_READWRITE |
         *                              G_PARAM_STATIC_STRINGS |
         *                              G_PARAM_EXPLICIT_NOTIFY);
         * ```
         *
         * When implementing the `GObjectClass.set_property` and `GObjectClass.get_property`
         * virtual functions, you must use [func`Gtk`.value_get_expression], to retrieve the
         * stored `GtkExpression` from the `GValue` container, and [func`Gtk`.value_set_expression],
         * to store the `GtkExpression` into the `GValue`; for instance:
         *
         * ```c
         *   // in set_property()...
         *   case PROP_EXPRESSION:
         *     foo_widget_set_expression (foo, gtk_value_get_expression (value));
         *     break;
         *
         *   // in get_property()...
         *   case PROP_EXPRESSION:
         *     gtk_value_set_expression (value, foo->expression);
         *     break;
         * ```
         *
         * ## GtkExpression in .ui files
         *
         * `GtkBuilder` has support for creating expressions. The syntax here can be used where
         * a `GtkExpression` object is needed like in a `<property>` tag for an expression
         * property, or in a `<binding name="property">` tag to bind a property to an expression.
         *
         * To create a property expression, use the `<lookup>` element. It can have a `type`
         * attribute to specify the object type, and a `name` attribute to specify the property
         * to look up. The content of `<lookup>` can either be a string that specifies the name
         * of the object to use, an element specifying an expression to provide an object, or
         * empty to use the `this` object.
         *
         * Example:
         *
         * ```xml
         *   <lookup name='search'>string_filter</lookup>
         * ```
         *
         * Since the `<lookup>` element creates an expression and its element content can
         * itself be an expression, this means that `<lookup>` tags can also be nested.
         * This is a common idiom when dealing with `GtkListItem`s. See
         * [class`Gtk`.BuilderListItemFactory] for an example of this technique.
         *
         * To create a constant expression, use the `<constant>` element. If the type attribute
         * is specified, the element content is interpreted as a value of that type. Otherwise,
         * it is assumed to be an object. For instance:
         *
         * ```xml
         *   <constant>string_filter</constant>
         *   <constant type='gchararray'>Hello, world</constant>
         * ```
         *
         * To create a closure expression, use the `<closure>` element. The `function`
         * attribute specifies what function to use for the closure, and the `type`
         * attribute specifies its return type. The content of the element contains the
         * expressions for the parameters. For instance:
         *
         * ```xml
         *   <closure type='gchararray' function='combine_args_somehow'>
         *     <constant type='gchararray'>File size:</constant>
         *     <lookup type='GFile' name='size'>myfile</lookup>
         *   </closure>
         * ```
         *
         * To create a property binding, use the `<binding>` element in place of where a
         * `<property>` tag would ordinarily be used. The `name` and `object` attributes are
         * supported. The `name` attribute is required, and pertains to the applicable property
         * name. The `object` attribute is optional. If provided, it will use the specified object
         * as the `this` object when the expression is evaluated. Here is an example in which the
         * `label` property of a `GtkLabel` is bound to the `string` property of another arbitrary
         * object:
         *
         * ```xml
         *   <object class='GtkLabel'>
         *     <binding name='label'>
         *       <lookup name='string'>some_other_object</lookup>
         *     </binding>
         *   </object>
         * ```
         */
        abstract class Expression {
            static $gtype: GObject.GType<Expression>;

            // Constructors

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

            // Methods

            /**
             * Bind `target`'s property named `property` to `self`.
             *
             * The value that `self` evaluates to is set via `g_object_set()` on
             * `target`. This is repeated whenever `self` changes to ensure that
             * the object's property stays synchronized with `self`.
             *
             * If `self`'s evaluation fails, `target`'s `property` is not updated.
             * You can ensure that this doesn't happen by using a fallback
             * expression.
             *
             * Note that this function takes ownership of `self`. If you want
             * to keep it around, you should [method`Gtk`.Expression.ref] it beforehand.
             * @param target the target object to bind to
             * @param property name of the property on `target` to bind to
             * @param this_ the this argument for   the evaluation of `self`
             * @returns a `GtkExpressionWatch`
             */
            bind(target: GObject.Object, property: string, this_?: GObject.Object | null): ExpressionWatch;
            /**
             * Evaluates the given expression and on success stores the result
             * in `value`.
             *
             * The `GType` of `value` will be the type given by
             * [method`Gtk`.Expression.get_value_type].
             *
             * It is possible that expressions cannot be evaluated - for example
             * when the expression references objects that have been destroyed or
             * set to `NULL`. In that case `value` will remain empty and `FALSE`
             * will be returned.
             * @param this_ the this argument for the evaluation
             * @param value an empty `GValue`
             * @returns `TRUE` if the expression could be evaluated
             */
            evaluate(this_: GObject.Object | null, value: GObject.Value | any): boolean;
            /**
             * Gets the `GType` that this expression evaluates to.
             *
             * This type is constant and will not change over the lifetime
             * of this expression.
             * @returns The type returned from [method@Gtk.Expression.evaluate]
             */
            get_value_type(): GObject.GType;
            /**
             * Checks if the expression is static.
             *
             * A static expression will never change its result when
             * [method`Gtk`.Expression.evaluate] is called on it with the same arguments.
             *
             * That means a call to [method`Gtk`.Expression.watch] is not necessary because
             * it will never trigger a notify.
             * @returns `TRUE` if the expression is static
             */
            is_static(): boolean;
            /**
             * Acquires a reference on the given `GtkExpression`.
             * @returns the `GtkExpression` with an additional reference
             */
            ref(): Expression;
            /**
             * Releases a reference on the given `GtkExpression`.
             *
             * If the reference was the last, the resources associated to the `self` are
             * freed.
             */
            unref(): void;
            /**
             * Watch the given `expression` for changes.
             *
             * The `notify` function will be called whenever the evaluation of `self`
             * may have changed.
             *
             * GTK cannot guarantee that the evaluation did indeed change when the `notify`
             * gets invoked, but it guarantees the opposite: When it did in fact change,
             * the `notify` will be invoked.
             * @param this_ the `this` argument to   watch
             * @param notify callback to invoke when the expression changes
             * @returns The newly installed watch. Note that the only   reference held to the watch will be released when the watch is unwatched   which can happen automatically, and not just via   [method@Gtk.ExpressionWatch.unwatch]. You should call [method@Gtk.ExpressionWatch.ref]   if you want to keep the watch around.
             */
            watch(this_: GObject.Object | null, notify: ExpressionNotify): ExpressionWatch;
        }

        namespace FileChooserDialog {
            // Constructor properties interface

            interface ConstructorProps
                extends Dialog.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    FileChooser.ConstructorProps,
                    Native.ConstructorProps,
                    Root.ConstructorProps,
                    ShortcutManager.ConstructorProps {}
        }

        /**
         * `GtkFileChooserDialog` is a dialog suitable for use with
         * “File Open” or “File Save” commands.
         *
         * ![An example GtkFileChooserDialog](filechooser.png)
         *
         * This widget works by putting a [class`Gtk`.FileChooserWidget]
         * inside a [class`Gtk`.Dialog]. It exposes the [iface`Gtk`.FileChooser]
         * interface, so you can use all of the [iface`Gtk`.FileChooser] functions
         * on the file chooser dialog as well as those for [class`Gtk`.Dialog].
         *
         * Note that `GtkFileChooserDialog` does not have any methods of its
         * own. Instead, you should use the functions that work on a
         * [iface`Gtk`.FileChooser].
         *
         * If you want to integrate well with the platform you should use the
         * [class`Gtk`.FileChooserNative] API, which will use a platform-specific
         * dialog if available and fall back to `GtkFileChooserDialog`
         * otherwise.
         *
         * ## Typical usage
         *
         * In the simplest of cases, you can the following code to use
         * `GtkFileChooserDialog` to select a file for opening:
         *
         * ```c
         * static void
         * on_open_response (GtkDialog *dialog,
         *                   int        response)
         * {
         *   if (response == GTK_RESPONSE_ACCEPT)
         *     {
         *       GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
         *
         *       g_autoptr(GFile) file = gtk_file_chooser_get_file (chooser);
         *
         *       open_file (file);
         *     }
         *
         *   gtk_window_destroy (GTK_WINDOW (dialog));
         * }
         *
         *   // ...
         *   GtkWidget *dialog;
         *   GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
         *
         *   dialog = gtk_file_chooser_dialog_new ("Open File",
         *                                         parent_window,
         *                                         action,
         *                                         _("_Cancel"),
         *                                         GTK_RESPONSE_CANCEL,
         *                                         _("_Open"),
         *                                         GTK_RESPONSE_ACCEPT,
         *                                         NULL);
         *
         *   gtk_window_present (GTK_WINDOW (dialog));
         *
         *   g_signal_connect (dialog, "response",
         *                     G_CALLBACK (on_open_response),
         *                     NULL);
         * ```
         *
         * To use a dialog for saving, you can use this:
         *
         * ```c
         * static void
         * on_save_response (GtkDialog *dialog,
         *                   int        response)
         * {
         *   if (response == GTK_RESPONSE_ACCEPT)
         *     {
         *       GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
         *
         *       g_autoptr(GFile) file = gtk_file_chooser_get_file (chooser);
         *
         *       save_to_file (file);
         *     }
         *
         *   gtk_window_destroy (GTK_WINDOW (dialog));
         * }
         *
         *   // ...
         *   GtkWidget *dialog;
         *   GtkFileChooser *chooser;
         *   GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE;
         *
         *   dialog = gtk_file_chooser_dialog_new ("Save File",
         *                                         parent_window,
         *                                         action,
         *                                         _("_Cancel"),
         *                                         GTK_RESPONSE_CANCEL,
         *                                         _("_Save"),
         *                                         GTK_RESPONSE_ACCEPT,
         *                                         NULL);
         *   chooser = GTK_FILE_CHOOSER (dialog);
         *
         *   if (user_edited_a_new_document)
         *     gtk_file_chooser_set_current_name (chooser, _("Untitled document"));
         *   else
         *     gtk_file_chooser_set_file (chooser, existing_filename);
         *
         *   gtk_window_present (GTK_WINDOW (dialog));
         *
         *   g_signal_connect (dialog, "response",
         *                     G_CALLBACK (on_save_response),
         *                     NULL);
         * ```
         *
         * ## Setting up a file chooser dialog
         *
         * There are various cases in which you may need to use a `GtkFileChooserDialog`:
         *
         * - To select a file for opening, use %GTK_FILE_CHOOSER_ACTION_OPEN.
         *
         * - To save a file for the first time, use %GTK_FILE_CHOOSER_ACTION_SAVE,
         *   and suggest a name such as “Untitled” with
         *   [method`Gtk`.FileChooser.set_current_name].
         *
         * - To save a file under a different name, use %GTK_FILE_CHOOSER_ACTION_SAVE,
         *   and set the existing file with [method`Gtk`.FileChooser.set_file].
         *
         * - To choose a folder instead of a filem use %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER.
         *
         * In general, you should only cause the file chooser to show a specific
         * folder when it is appropriate to use [method`Gtk`.FileChooser.set_file],
         * i.e. when you are doing a “Save As” command and you already have a file
         * saved somewhere.
         *
         * ## Response Codes
         *
         * `GtkFileChooserDialog` inherits from [class`Gtk`.Dialog], so buttons that
         * go in its action area have response codes such as %GTK_RESPONSE_ACCEPT and
         * %GTK_RESPONSE_CANCEL. For example, you could call
         * [ctor`Gtk`.FileChooserDialog.new] as follows:
         *
         * ```c
         * GtkWidget *dialog;
         * GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
         *
         * dialog = gtk_file_chooser_dialog_new ("Open File",
         *                                       parent_window,
         *                                       action,
         *                                       _("_Cancel"),
         *                                       GTK_RESPONSE_CANCEL,
         *                                       _("_Open"),
         *                                       GTK_RESPONSE_ACCEPT,
         *                                       NULL);
         * ```
         *
         * This will create buttons for “Cancel” and “Open” that use predefined
         * response identifiers from [enum`Gtk`.ResponseType].  For most dialog
         * boxes you can use your own custom response codes rather than the
         * ones in [enum`Gtk`.ResponseType], but `GtkFileChooserDialog` assumes that
         * its “accept”-type action, e.g. an “Open” or “Save” button,
         * will have one of the following response codes:
         *
         * - %GTK_RESPONSE_ACCEPT
         * - %GTK_RESPONSE_OK
         * - %GTK_RESPONSE_YES
         * - %GTK_RESPONSE_APPLY
         *
         * This is because `GtkFileChooserDialog` must intercept responses and switch
         * to folders if appropriate, rather than letting the dialog terminate — the
         * implementation uses these known response codes to know which responses can
         * be blocked if appropriate.
         *
         * To summarize, make sure you use a predefined response code
         * when you use `GtkFileChooserDialog` to ensure proper operation.
         *
         * ## CSS nodes
         *
         * `GtkFileChooserDialog` has a single CSS node with the name `window` and style
         * class `.filechooser`.
         */
        class FileChooserDialog
            extends Dialog
            implements Accessible, Buildable, ConstraintTarget, FileChooser, Native, Root, ShortcutManager
        {
            static $gtype: GObject.GType<FileChooserDialog>;

            // Constructors

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

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

            // Inherited properties
            /**
             * The type of operation that the file chooser is performing.
             */
            get action(): FileChooserAction;
            set action(val: FileChooserAction);
            /**
             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
             * will offer the user to create new folders.
             */
            get create_folders(): boolean;
            set create_folders(val: boolean);
            /**
             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
             * will offer the user to create new folders.
             */
            get createFolders(): boolean;
            set createFolders(val: boolean);
            /**
             * The current filter for selecting files that are displayed.
             */
            get filter(): FileFilter;
            set filter(val: FileFilter);
            /**
             * A `GListModel` containing the filters that have been
             * added with gtk_file_chooser_add_filter().
             *
             * The returned object should not be modified. It may
             * or may not be updated for later changes.
             */
            get filters(): Gio.ListModel;
            /**
             * Whether to allow multiple files to be selected.
             */
            get select_multiple(): boolean;
            set select_multiple(val: boolean);
            /**
             * Whether to allow multiple files to be selected.
             */
            get selectMultiple(): boolean;
            set selectMultiple(val: boolean);
            /**
             * A `GListModel` containing the shortcut folders that have been
             * added with gtk_file_chooser_add_shortcut_folder().
             *
             * The returned object should not be modified. It may
             * or may not be updated for later changes.
             */
            get shortcut_folders(): Gio.ListModel;
            /**
             * A `GListModel` containing the shortcut folders that have been
             * added with gtk_file_chooser_add_shortcut_folder().
             *
             * The returned object should not be modified. It may
             * or may not be updated for later changes.
             */
            get shortcutFolders(): Gio.ListModel;
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Adds a 'choice' to the file chooser.
             *
             * This is typically implemented as a combobox or, for boolean choices,
             * as a checkbutton. You can select a value using
             * [method`Gtk`.FileChooser.set_choice] before the dialog is shown,
             * and you can obtain the user-selected value in the
             * [signal`Gtk`.Dialog::response] signal handler using
             * [method`Gtk`.FileChooser.get_choice].
             * @param id id for the added choice
             * @param label user-visible label for the added choice
             * @param options ids for the options of the choice, or %NULL for a boolean choice
             * @param option_labels user-visible labels for the options, must be the same length as @options
             */
            add_choice(id: string, label: string, options?: string[] | null, option_labels?: string[] | null): void;
            /**
             * Adds `filter` to the list of filters that the user can select between.
             *
             * When a filter is selected, only files that are passed by that
             * filter are displayed.
             *
             * Note that the `chooser` takes ownership of the filter if it is floating,
             * so you have to ref and sink it if you want to keep a reference.
             * @param filter a `GtkFileFilter`
             */
            add_filter(filter: FileFilter): void;
            /**
             * Adds a folder to be displayed with the shortcut folders
             * in a file chooser.
             * @param folder a `GFile` for the folder to add
             * @returns %TRUE if the folder could be added successfully,   %FALSE otherwise.
             */
            add_shortcut_folder(folder: Gio.File): boolean;
            /**
             * Gets the type of operation that the file chooser is performing.
             * @returns the action that the file selector is performing
             */
            get_action(): FileChooserAction;
            /**
             * Gets the currently selected option in the 'choice' with the given ID.
             * @param id the ID of the choice to get
             * @returns the ID of the currently selected option
             */
            get_choice(id: string): string | null;
            /**
             * Gets whether file chooser will offer to create new folders.
             * @returns %TRUE if the Create Folder button should be displayed.
             */
            get_create_folders(): boolean;
            /**
             * Gets the current folder of `chooser` as `GFile`.
             * @returns the `GFile` for the current folder.
             */
            get_current_folder(): Gio.File | null;
            /**
             * Gets the current name in the file selector, as entered by the user.
             *
             * This is meant to be used in save dialogs, to get the currently typed
             * filename when the file itself does not exist yet.
             * @returns The raw text from the file chooser’s “Name” entry. Free with   g_free(). Note that this string is not a full pathname or URI; it is   whatever the contents of the entry are. Note also that this string is   in UTF-8 encoding, which is not necessarily the system’s encoding for   filenames.
             */
            get_current_name(): string | null;
            /**
             * Gets the `GFile` for the currently selected file in
             * the file selector.
             *
             * If multiple files are selected, one of the files will be
             * returned at random.
             *
             * If the file chooser is in folder mode, this function returns
             * the selected folder.
             * @returns a selected `GFile`. You own the   returned file; use g_object_unref() to release it.
             */
            get_file(): Gio.File | null;
            /**
             * Lists all the selected files and subfolders in the current folder
             * of `chooser` as `GFile`.
             * @returns a list model containing a `GFile` for each   selected file and subfolder in the current folder. Free the returned   list with g_object_unref().
             */
            get_files(): Gio.ListModel;
            /**
             * Gets the current filter.
             * @returns the current filter
             */
            get_filter(): FileFilter | null;
            /**
             * Gets the current set of user-selectable filters, as a list model.
             *
             * See [method`Gtk`.FileChooser.add_filter] and
             * [method`Gtk`.FileChooser.remove_filter] for changing individual filters.
             *
             * You should not modify the returned list model. Future changes to
             * `chooser` may or may not affect the returned model.
             * @returns a `GListModel` containing the current set   of user-selectable filters.
             */
            get_filters(): Gio.ListModel;
            /**
             * Gets whether multiple files can be selected in the file
             * chooser.
             * @returns %TRUE if multiple files can be selected.
             */
            get_select_multiple(): boolean;
            /**
             * Queries the list of shortcut folders in the file chooser.
             *
             * You should not modify the returned list model. Future changes to
             * `chooser` may or may not affect the returned model.
             * @returns A list model of `GFile`s
             */
            get_shortcut_folders(): Gio.ListModel;
            /**
             * Removes a 'choice' that has been added with gtk_file_chooser_add_choice().
             * @param id the ID of the choice to remove
             */
            remove_choice(id: string): void;
            /**
             * Removes `filter` from the list of filters that the user can select between.
             * @param filter a `GtkFileFilter`
             */
            remove_filter(filter: FileFilter): void;
            /**
             * Removes a folder from the shortcut folders in a file chooser.
             * @param folder a `GFile` for the folder to remove
             * @returns %TRUE if the folder could be removed successfully,   %FALSE otherwise.
             */
            remove_shortcut_folder(folder: Gio.File): boolean;
            /**
             * Sets the type of operation that the chooser is performing.
             *
             * The user interface is adapted to suit the selected action.
             *
             * For example, an option to create a new folder might be shown
             * if the action is %GTK_FILE_CHOOSER_ACTION_SAVE but not if the
             * action is %GTK_FILE_CHOOSER_ACTION_OPEN.
             * @param action the action that the file selector is performing
             */
            set_action(action: FileChooserAction | null): void;
            /**
             * Selects an option in a 'choice' that has been added with
             * gtk_file_chooser_add_choice().
             *
             * For a boolean choice, the possible options are "true" and "false".
             * @param id the ID of the choice to set
             * @param option the ID of the option to select
             */
            set_choice(id: string, option: string): void;
            /**
             * Sets whether file chooser will offer to create new folders.
             *
             * This is only relevant if the action is not set to be
             * %GTK_FILE_CHOOSER_ACTION_OPEN.
             * @param create_folders %TRUE if the Create Folder button should be displayed
             */
            set_create_folders(create_folders: boolean): void;
            /**
             * Sets the current folder for `chooser` from a `GFile`.
             * @param file the `GFile` for the new folder
             * @returns %TRUE if the folder could be changed successfully, %FALSE   otherwise.
             */
            set_current_folder(file?: Gio.File | null): boolean;
            /**
             * Sets the current name in the file selector, as if entered
             * by the user.
             *
             * Note that the name passed in here is a UTF-8 string rather
             * than a filename. This function is meant for such uses as a
             * suggested name in a “Save As...” dialog.  You can pass
             * “Untitled.doc” or a similarly suitable suggestion for the `name`.
             *
             * If you want to preselect a particular existing file, you should
             * use [method`Gtk`.FileChooser.set_file] instead.
             *
             * Please see the documentation for those functions for an example
             * of using [method`Gtk`.FileChooser.set_current_name] as well.
             * @param name the filename to use, as a UTF-8 string
             */
            set_current_name(name: string): void;
            /**
             * Sets `file` as the current filename for the file chooser.
             *
             * This includes changing to the file’s parent folder and actually selecting
             * the file in list. If the `chooser` is in %GTK_FILE_CHOOSER_ACTION_SAVE mode,
             * the file’s base name will also appear in the dialog’s file name entry.
             *
             * If the file name isn’t in the current folder of `chooser,` then the current
             * folder of `chooser` will be changed to the folder containing `file`.
             *
             * Note that the file must exist, or nothing will be done except
             * for the directory change.
             *
             * If you are implementing a save dialog, you should use this function if
             * you already have a file name to which the user may save; for example,
             * when the user opens an existing file and then does “Save As…”. If you
             * don’t have a file name already — for example, if the user just created
             * a new file and is saving it for the first time, do not call this function.
             *
             * Instead, use something similar to this:
             *
             * ```c
             * static void
             * prepare_file_chooser (GtkFileChooser *chooser,
             *                       GFile          *existing_file)
             * {
             *   gboolean document_is_new = (existing_file == NULL);
             *
             *   if (document_is_new)
             *     {
             *       GFile *default_file_for_saving = g_file_new_for_path ("./out.txt");
             *       // the user just created a new document
             *       gtk_file_chooser_set_current_folder (chooser, default_file_for_saving, NULL);
             *       gtk_file_chooser_set_current_name (chooser, "Untitled document");
             *       g_object_unref (default_file_for_saving);
             *     }
             *   else
             *     {
             *       // the user edited an existing document
             *       gtk_file_chooser_set_file (chooser, existing_file, NULL);
             *     }
             * }
             * ```
             * @param file the `GFile` to set as current
             * @returns Not useful
             */
            set_file(file: Gio.File): boolean;
            /**
             * Sets the current filter.
             *
             * Only the files that pass the filter will be displayed.
             * If the user-selectable list of filters is non-empty, then
             * the filter should be one of the filters in that list.
             *
             * Setting the current filter when the list of filters is
             * empty is useful if you want to restrict the displayed
             * set of files without letting the user change it.
             * @param filter a `GtkFileFilter`
             */
            set_filter(filter: FileFilter): void;
            /**
             * Sets whether multiple files can be selected in the file chooser.
             *
             * This is only relevant if the action is set to be
             * %GTK_FILE_CHOOSER_ACTION_OPEN or
             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER.
             * @param select_multiple %TRUE if multiple files can be selected.
             */
            set_select_multiple(select_multiple: boolean): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace FileChooserNative {
            // Constructor properties interface

            interface ConstructorProps extends NativeDialog.ConstructorProps, FileChooser.ConstructorProps {
                accept_label: string;
                acceptLabel: string;
                cancel_label: string;
                cancelLabel: string;
            }
        }

        /**
         * `GtkFileChooserNative` is an abstraction of a dialog suitable
         * for use with “File Open” or “File Save as” commands.
         *
         * By default, this just uses a `GtkFileChooserDialog` to implement
         * the actual dialog. However, on some platforms, such as Windows and
         * macOS, the native platform file chooser is used instead. When the
         * application is running in a sandboxed environment without direct
         * filesystem access (such as Flatpak), `GtkFileChooserNative` may call
         * the proper APIs (portals) to let the user choose a file and make it
         * available to the application.
         *
         * While the API of `GtkFileChooserNative` closely mirrors `GtkFileChooserDialog`,
         * the main difference is that there is no access to any `GtkWindow` or `GtkWidget`
         * for the dialog. This is required, as there may not be one in the case of a
         * platform native dialog.
         *
         * Showing, hiding and running the dialog is handled by the
         * [class`Gtk`.NativeDialog] functions.
         *
         * Note that unlike `GtkFileChooserDialog`, `GtkFileChooserNative` objects
         * are not toplevel widgets, and GTK does not keep them alive. It is your
         * responsibility to keep a reference until you are done with the
         * object.
         *
         * ## Typical usage
         *
         * In the simplest of cases, you can the following code to use
         * `GtkFileChooserNative` to select a file for opening:
         *
         * ```c
         * static void
         * on_response (GtkNativeDialog *native,
         *              int              response)
         * {
         *   if (response == GTK_RESPONSE_ACCEPT)
         *     {
         *       GtkFileChooser *chooser = GTK_FILE_CHOOSER (native);
         *       GFile *file = gtk_file_chooser_get_file (chooser);
         *
         *       open_file (file);
         *
         *       g_object_unref (file);
         *     }
         *
         *   g_object_unref (native);
         * }
         *
         *   // ...
         *   GtkFileChooserNative *native;
         *   GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
         *
         *   native = gtk_file_chooser_native_new ("Open File",
         *                                         parent_window,
         *                                         action,
         *                                         "_Open",
         *                                         "_Cancel");
         *
         *   g_signal_connect (native, "response", G_CALLBACK (on_response), NULL);
         *   gtk_native_dialog_show (GTK_NATIVE_DIALOG (native));
         * ```
         *
         * To use a `GtkFileChooserNative` for saving, you can use this:
         *
         * ```c
         * static void
         * on_response (GtkNativeDialog *native,
         *              int              response)
         * {
         *   if (response == GTK_RESPONSE_ACCEPT)
         *     {
         *       GtkFileChooser *chooser = GTK_FILE_CHOOSER (native);
         *       GFile *file = gtk_file_chooser_get_file (chooser);
         *
         *       save_to_file (file);
         *
         *       g_object_unref (file);
         *     }
         *
         *   g_object_unref (native);
         * }
         *
         *   // ...
         *   GtkFileChooserNative *native;
         *   GtkFileChooser *chooser;
         *   GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE;
         *
         *   native = gtk_file_chooser_native_new ("Save File",
         *                                         parent_window,
         *                                         action,
         *                                         "_Save",
         *                                         "_Cancel");
         *   chooser = GTK_FILE_CHOOSER (native);
         *
         *   if (user_edited_a_new_document)
         *     gtk_file_chooser_set_current_name (chooser, _("Untitled document"));
         *   else
         *     gtk_file_chooser_set_file (chooser, existing_file, NULL);
         *
         *   g_signal_connect (native, "response", G_CALLBACK (on_response), NULL);
         *   gtk_native_dialog_show (GTK_NATIVE_DIALOG (native));
         * ```
         *
         * For more information on how to best set up a file dialog,
         * see the [class`Gtk`.FileChooserDialog] documentation.
         *
         * ## Response Codes
         *
         * `GtkFileChooserNative` inherits from [class`Gtk`.NativeDialog],
         * which means it will return %GTK_RESPONSE_ACCEPT if the user accepted,
         * and %GTK_RESPONSE_CANCEL if he pressed cancel. It can also return
         * %GTK_RESPONSE_DELETE_EVENT if the window was unexpectedly closed.
         *
         * ## Differences from `GtkFileChooserDialog`
         *
         * There are a few things in the [iface`Gtk`.FileChooser] interface that
         * are not possible to use with `GtkFileChooserNative`, as such use would
         * prohibit the use of a native dialog.
         *
         * No operations that change the dialog work while the dialog is visible.
         * Set all the properties that are required before showing the dialog.
         *
         * ## Win32 details
         *
         * On windows the `IFileDialog` implementation (added in Windows Vista) is
         * used. It supports many of the features that `GtkFileChooser` has, but
         * there are some things it does not handle:
         *
         * * Any [class`Gtk`.FileFilter] added using a mimetype
         *
         * If any of these features are used the regular `GtkFileChooserDialog`
         * will be used in place of the native one.
         *
         * ## Portal details
         *
         * When the `org.freedesktop.portal.FileChooser` portal is available on
         * the session bus, it is used to bring up an out-of-process file chooser.
         * Depending on the kind of session the application is running in, this may
         * or may not be a GTK file chooser.
         *
         * ## macOS details
         *
         * On macOS the `NSSavePanel` and `NSOpenPanel` classes are used to provide
         * native file chooser dialogs. Some features provided by `GtkFileChooser`
         * are not supported:
         *
         * * Shortcut folders.
         */
        class FileChooserNative extends NativeDialog implements FileChooser {
            static $gtype: GObject.GType<FileChooserNative>;

            // Properties

            /**
             * The text used for the label on the accept button in the dialog, or
             * %NULL to use the default text.
             */
            get accept_label(): string;
            set accept_label(val: string);
            /**
             * The text used for the label on the accept button in the dialog, or
             * %NULL to use the default text.
             */
            get acceptLabel(): string;
            set acceptLabel(val: string);
            /**
             * The text used for the label on the cancel button in the dialog, or
             * %NULL to use the default text.
             */
            get cancel_label(): string;
            set cancel_label(val: string);
            /**
             * The text used for the label on the cancel button in the dialog, or
             * %NULL to use the default text.
             */
            get cancelLabel(): string;
            set cancelLabel(val: string);

            // Constructors

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

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

            static ['new'](
                title: string | null,
                parent: Window | null,
                action: FileChooserAction,
                accept_label?: string | null,
                cancel_label?: string | null,
            ): FileChooserNative;

            // Methods

            /**
             * Retrieves the custom label text for the accept button.
             * @returns The custom label
             */
            get_accept_label(): string | null;
            /**
             * Retrieves the custom label text for the cancel button.
             * @returns The custom label
             */
            get_cancel_label(): string | null;
            /**
             * Sets the custom label text for the accept button.
             *
             * If characters in `label` are preceded by an underscore, they are
             * underlined. If you need a literal underscore character in a label,
             * use “__” (two underscores). The first underlined character represents
             * a keyboard accelerator called a mnemonic.
             *
             * Pressing Alt and that key should activate the button.
             * @param accept_label custom label
             */
            set_accept_label(accept_label?: string | null): void;
            /**
             * Sets the custom label text for the cancel button.
             *
             * If characters in `label` are preceded by an underscore, they are
             * underlined. If you need a literal underscore character in a label,
             * use “__” (two underscores). The first underlined character represents
             * a keyboard accelerator called a mnemonic.
             *
             * Pressing Alt and that key should activate the button.
             * @param cancel_label custom label
             */
            set_cancel_label(cancel_label?: string | null): void;

            // Inherited properties
            /**
             * The type of operation that the file chooser is performing.
             */
            get action(): FileChooserAction;
            set action(val: FileChooserAction);
            /**
             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
             * will offer the user to create new folders.
             */
            get create_folders(): boolean;
            set create_folders(val: boolean);
            /**
             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
             * will offer the user to create new folders.
             */
            get createFolders(): boolean;
            set createFolders(val: boolean);
            /**
             * The current filter for selecting files that are displayed.
             */
            get filter(): FileFilter;
            set filter(val: FileFilter);
            /**
             * A `GListModel` containing the filters that have been
             * added with gtk_file_chooser_add_filter().
             *
             * The returned object should not be modified. It may
             * or may not be updated for later changes.
             */
            get filters(): Gio.ListModel;
            /**
             * Whether to allow multiple files to be selected.
             */
            get select_multiple(): boolean;
            set select_multiple(val: boolean);
            /**
             * Whether to allow multiple files to be selected.
             */
            get selectMultiple(): boolean;
            set selectMultiple(val: boolean);
            /**
             * A `GListModel` containing the shortcut folders that have been
             * added with gtk_file_chooser_add_shortcut_folder().
             *
             * The returned object should not be modified. It may
             * or may not be updated for later changes.
             */
            get shortcut_folders(): Gio.ListModel;
            /**
             * A `GListModel` containing the shortcut folders that have been
             * added with gtk_file_chooser_add_shortcut_folder().
             *
             * The returned object should not be modified. It may
             * or may not be updated for later changes.
             */
            get shortcutFolders(): Gio.ListModel;

            // Inherited methods
            /**
             * Adds a 'choice' to the file chooser.
             *
             * This is typically implemented as a combobox or, for boolean choices,
             * as a checkbutton. You can select a value using
             * [method`Gtk`.FileChooser.set_choice] before the dialog is shown,
             * and you can obtain the user-selected value in the
             * [signal`Gtk`.Dialog::response] signal handler using
             * [method`Gtk`.FileChooser.get_choice].
             * @param id id for the added choice
             * @param label user-visible label for the added choice
             * @param options ids for the options of the choice, or %NULL for a boolean choice
             * @param option_labels user-visible labels for the options, must be the same length as @options
             */
            add_choice(id: string, label: string, options?: string[] | null, option_labels?: string[] | null): void;
            /**
             * Adds `filter` to the list of filters that the user can select between.
             *
             * When a filter is selected, only files that are passed by that
             * filter are displayed.
             *
             * Note that the `chooser` takes ownership of the filter if it is floating,
             * so you have to ref and sink it if you want to keep a reference.
             * @param filter a `GtkFileFilter`
             */
            add_filter(filter: FileFilter): void;
            /**
             * Adds a folder to be displayed with the shortcut folders
             * in a file chooser.
             * @param folder a `GFile` for the folder to add
             * @returns %TRUE if the folder could be added successfully,   %FALSE otherwise.
             */
            add_shortcut_folder(folder: Gio.File): boolean;
            /**
             * Gets the type of operation that the file chooser is performing.
             * @returns the action that the file selector is performing
             */
            get_action(): FileChooserAction;
            /**
             * Gets the currently selected option in the 'choice' with the given ID.
             * @param id the ID of the choice to get
             * @returns the ID of the currently selected option
             */
            get_choice(id: string): string | null;
            /**
             * Gets whether file chooser will offer to create new folders.
             * @returns %TRUE if the Create Folder button should be displayed.
             */
            get_create_folders(): boolean;
            /**
             * Gets the current folder of `chooser` as `GFile`.
             * @returns the `GFile` for the current folder.
             */
            get_current_folder(): Gio.File | null;
            /**
             * Gets the current name in the file selector, as entered by the user.
             *
             * This is meant to be used in save dialogs, to get the currently typed
             * filename when the file itself does not exist yet.
             * @returns The raw text from the file chooser’s “Name” entry. Free with   g_free(). Note that this string is not a full pathname or URI; it is   whatever the contents of the entry are. Note also that this string is   in UTF-8 encoding, which is not necessarily the system’s encoding for   filenames.
             */
            get_current_name(): string | null;
            /**
             * Gets the `GFile` for the currently selected file in
             * the file selector.
             *
             * If multiple files are selected, one of the files will be
             * returned at random.
             *
             * If the file chooser is in folder mode, this function returns
             * the selected folder.
             * @returns a selected `GFile`. You own the   returned file; use g_object_unref() to release it.
             */
            get_file(): Gio.File | null;
            /**
             * Lists all the selected files and subfolders in the current folder
             * of `chooser` as `GFile`.
             * @returns a list model containing a `GFile` for each   selected file and subfolder in the current folder. Free the returned   list with g_object_unref().
             */
            get_files(): Gio.ListModel;
            /**
             * Gets the current filter.
             * @returns the current filter
             */
            get_filter(): FileFilter | null;
            /**
             * Gets the current set of user-selectable filters, as a list model.
             *
             * See [method`Gtk`.FileChooser.add_filter] and
             * [method`Gtk`.FileChooser.remove_filter] for changing individual filters.
             *
             * You should not modify the returned list model. Future changes to
             * `chooser` may or may not affect the returned model.
             * @returns a `GListModel` containing the current set   of user-selectable filters.
             */
            get_filters(): Gio.ListModel;
            /**
             * Gets whether multiple files can be selected in the file
             * chooser.
             * @returns %TRUE if multiple files can be selected.
             */
            get_select_multiple(): boolean;
            /**
             * Queries the list of shortcut folders in the file chooser.
             *
             * You should not modify the returned list model. Future changes to
             * `chooser` may or may not affect the returned model.
             * @returns A list model of `GFile`s
             */
            get_shortcut_folders(): Gio.ListModel;
            /**
             * Removes a 'choice' that has been added with gtk_file_chooser_add_choice().
             * @param id the ID of the choice to remove
             */
            remove_choice(id: string): void;
            /**
             * Removes `filter` from the list of filters that the user can select between.
             * @param filter a `GtkFileFilter`
             */
            remove_filter(filter: FileFilter): void;
            /**
             * Removes a folder from the shortcut folders in a file chooser.
             * @param folder a `GFile` for the folder to remove
             * @returns %TRUE if the folder could be removed successfully,   %FALSE otherwise.
             */
            remove_shortcut_folder(folder: Gio.File): boolean;
            /**
             * Sets the type of operation that the chooser is performing.
             *
             * The user interface is adapted to suit the selected action.
             *
             * For example, an option to create a new folder might be shown
             * if the action is %GTK_FILE_CHOOSER_ACTION_SAVE but not if the
             * action is %GTK_FILE_CHOOSER_ACTION_OPEN.
             * @param action the action that the file selector is performing
             */
            set_action(action: FileChooserAction | null): void;
            /**
             * Selects an option in a 'choice' that has been added with
             * gtk_file_chooser_add_choice().
             *
             * For a boolean choice, the possible options are "true" and "false".
             * @param id the ID of the choice to set
             * @param option the ID of the option to select
             */
            set_choice(id: string, option: string): void;
            /**
             * Sets whether file chooser will offer to create new folders.
             *
             * This is only relevant if the action is not set to be
             * %GTK_FILE_CHOOSER_ACTION_OPEN.
             * @param create_folders %TRUE if the Create Folder button should be displayed
             */
            set_create_folders(create_folders: boolean): void;
            /**
             * Sets the current folder for `chooser` from a `GFile`.
             * @param file the `GFile` for the new folder
             * @returns %TRUE if the folder could be changed successfully, %FALSE   otherwise.
             */
            set_current_folder(file?: Gio.File | null): boolean;
            /**
             * Sets the current name in the file selector, as if entered
             * by the user.
             *
             * Note that the name passed in here is a UTF-8 string rather
             * than a filename. This function is meant for such uses as a
             * suggested name in a “Save As...” dialog.  You can pass
             * “Untitled.doc” or a similarly suitable suggestion for the `name`.
             *
             * If you want to preselect a particular existing file, you should
             * use [method`Gtk`.FileChooser.set_file] instead.
             *
             * Please see the documentation for those functions for an example
             * of using [method`Gtk`.FileChooser.set_current_name] as well.
             * @param name the filename to use, as a UTF-8 string
             */
            set_current_name(name: string): void;
            /**
             * Sets `file` as the current filename for the file chooser.
             *
             * This includes changing to the file’s parent folder and actually selecting
             * the file in list. If the `chooser` is in %GTK_FILE_CHOOSER_ACTION_SAVE mode,
             * the file’s base name will also appear in the dialog’s file name entry.
             *
             * If the file name isn’t in the current folder of `chooser,` then the current
             * folder of `chooser` will be changed to the folder containing `file`.
             *
             * Note that the file must exist, or nothing will be done except
             * for the directory change.
             *
             * If you are implementing a save dialog, you should use this function if
             * you already have a file name to which the user may save; for example,
             * when the user opens an existing file and then does “Save As…”. If you
             * don’t have a file name already — for example, if the user just created
             * a new file and is saving it for the first time, do not call this function.
             *
             * Instead, use something similar to this:
             *
             * ```c
             * static void
             * prepare_file_chooser (GtkFileChooser *chooser,
             *                       GFile          *existing_file)
             * {
             *   gboolean document_is_new = (existing_file == NULL);
             *
             *   if (document_is_new)
             *     {
             *       GFile *default_file_for_saving = g_file_new_for_path ("./out.txt");
             *       // the user just created a new document
             *       gtk_file_chooser_set_current_folder (chooser, default_file_for_saving, NULL);
             *       gtk_file_chooser_set_current_name (chooser, "Untitled document");
             *       g_object_unref (default_file_for_saving);
             *     }
             *   else
             *     {
             *       // the user edited an existing document
             *       gtk_file_chooser_set_file (chooser, existing_file, NULL);
             *     }
             * }
             * ```
             * @param file the `GFile` to set as current
             * @returns Not useful
             */
            set_file(file: Gio.File): boolean;
            /**
             * Sets the current filter.
             *
             * Only the files that pass the filter will be displayed.
             * If the user-selectable list of filters is non-empty, then
             * the filter should be one of the filters in that list.
             *
             * Setting the current filter when the list of filters is
             * empty is useful if you want to restrict the displayed
             * set of files without letting the user change it.
             * @param filter a `GtkFileFilter`
             */
            set_filter(filter: FileFilter): void;
            /**
             * Sets whether multiple files can be selected in the file chooser.
             *
             * This is only relevant if the action is set to be
             * %GTK_FILE_CHOOSER_ACTION_OPEN or
             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER.
             * @param select_multiple %TRUE if multiple files can be selected.
             */
            set_select_multiple(select_multiple: boolean): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace FileChooserWidget {
            // Signal callback interfaces

            interface DesktopFolder {
                (): void;
            }

            interface DownFolder {
                (): void;
            }

            interface HomeFolder {
                (): void;
            }

            interface LocationPopup {
                (path: string): void;
            }

            interface LocationPopupOnPaste {
                (): void;
            }

            interface LocationTogglePopup {
                (): void;
            }

            interface PlacesShortcut {
                (): void;
            }

            interface QuickBookmark {
                (bookmark_index: number): void;
            }

            interface RecentShortcut {
                (): void;
            }

            interface SearchShortcut {
                (): void;
            }

            interface ShowHidden {
                (): void;
            }

            interface UpFolder {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    FileChooser.ConstructorProps {
                search_mode: boolean;
                searchMode: boolean;
                show_time: boolean;
                showTime: boolean;
                subtitle: string;
            }
        }

        /**
         * `GtkFileChooserWidget` is a widget for choosing files.
         *
         * It exposes the [iface`Gtk`.FileChooser] interface, and you should
         * use the methods of this interface to interact with the
         * widget.
         *
         * # Shortcuts and Gestures
         *
         * `GtkFileChooserWidget` supports the following keyboard shortcuts:
         *
         * - <kbd>Shift</kbd>+<kbd>F10</kbd> or <kbd>Menu</kbd> opens the context menu.
         *
         * The following signals have default keybindings:
         *
         * - [signal`Gtk`.FileChooserWidget::desktop-folder]
         * - [signal`Gtk`.FileChooserWidget::down-folder]
         * - [signal`Gtk`.FileChooserWidget::home-folder]
         * - [signal`Gtk`.FileChooserWidget::location-popup]
         * - [signal`Gtk`.FileChooserWidget::location-popup-on-paste]
         * - [signal`Gtk`.FileChooserWidget::location-toggle-popup]
         * - [signal`Gtk`.FileChooserWidget::places-shortcut]
         * - [signal`Gtk`.FileChooserWidget::quick-bookmark]
         * - [signal`Gtk`.FileChooserWidget::recent-shortcut]
         * - [signal`Gtk`.FileChooserWidget::search-shortcut]
         * - [signal`Gtk`.FileChooserWidget::show-hidden]
         * - [signal`Gtk`.FileChooserWidget::up-folder]
         *
         * # CSS nodes
         *
         * `GtkFileChooserWidget` has a single CSS node with name filechooser.
         */
        class FileChooserWidget extends Widget implements Accessible, Buildable, ConstraintTarget, FileChooser {
            static $gtype: GObject.GType<FileChooserWidget>;

            // Properties

            /**
             * Whether search mode is enabled.
             */
            get search_mode(): boolean;
            set search_mode(val: boolean);
            /**
             * Whether search mode is enabled.
             */
            get searchMode(): boolean;
            set searchMode(val: boolean);
            /**
             * Whether to show the time.
             */
            get show_time(): boolean;
            /**
             * Whether to show the time.
             */
            get showTime(): boolean;
            /**
             * The subtitle of the file chooser widget.
             */
            get subtitle(): string;

            // Constructors

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

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

            static ['new'](action: FileChooserAction): FileChooserWidget;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'desktop-folder', callback: (_source: this) => void): number;
            connect_after(signal: 'desktop-folder', callback: (_source: this) => void): number;
            emit(signal: 'desktop-folder'): void;
            connect(signal: 'down-folder', callback: (_source: this) => void): number;
            connect_after(signal: 'down-folder', callback: (_source: this) => void): number;
            emit(signal: 'down-folder'): void;
            connect(signal: 'home-folder', callback: (_source: this) => void): number;
            connect_after(signal: 'home-folder', callback: (_source: this) => void): number;
            emit(signal: 'home-folder'): void;
            connect(signal: 'location-popup', callback: (_source: this, path: string) => void): number;
            connect_after(signal: 'location-popup', callback: (_source: this, path: string) => void): number;
            emit(signal: 'location-popup', path: string): void;
            connect(signal: 'location-popup-on-paste', callback: (_source: this) => void): number;
            connect_after(signal: 'location-popup-on-paste', callback: (_source: this) => void): number;
            emit(signal: 'location-popup-on-paste'): void;
            connect(signal: 'location-toggle-popup', callback: (_source: this) => void): number;
            connect_after(signal: 'location-toggle-popup', callback: (_source: this) => void): number;
            emit(signal: 'location-toggle-popup'): void;
            connect(signal: 'places-shortcut', callback: (_source: this) => void): number;
            connect_after(signal: 'places-shortcut', callback: (_source: this) => void): number;
            emit(signal: 'places-shortcut'): void;
            connect(signal: 'quick-bookmark', callback: (_source: this, bookmark_index: number) => void): number;
            connect_after(signal: 'quick-bookmark', callback: (_source: this, bookmark_index: number) => void): number;
            emit(signal: 'quick-bookmark', bookmark_index: number): void;
            connect(signal: 'recent-shortcut', callback: (_source: this) => void): number;
            connect_after(signal: 'recent-shortcut', callback: (_source: this) => void): number;
            emit(signal: 'recent-shortcut'): void;
            connect(signal: 'search-shortcut', callback: (_source: this) => void): number;
            connect_after(signal: 'search-shortcut', callback: (_source: this) => void): number;
            emit(signal: 'search-shortcut'): void;
            connect(signal: 'show-hidden', callback: (_source: this) => void): number;
            connect_after(signal: 'show-hidden', callback: (_source: this) => void): number;
            emit(signal: 'show-hidden'): void;
            connect(signal: 'up-folder', callback: (_source: this) => void): number;
            connect_after(signal: 'up-folder', callback: (_source: this) => void): number;
            emit(signal: 'up-folder'): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The type of operation that the file chooser is performing.
             */
            get action(): FileChooserAction;
            set action(val: FileChooserAction);
            /**
             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
             * will offer the user to create new folders.
             */
            get create_folders(): boolean;
            set create_folders(val: boolean);
            /**
             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
             * will offer the user to create new folders.
             */
            get createFolders(): boolean;
            set createFolders(val: boolean);
            /**
             * The current filter for selecting files that are displayed.
             */
            get filter(): FileFilter;
            set filter(val: FileFilter);
            /**
             * A `GListModel` containing the filters that have been
             * added with gtk_file_chooser_add_filter().
             *
             * The returned object should not be modified. It may
             * or may not be updated for later changes.
             */
            get filters(): Gio.ListModel;
            /**
             * Whether to allow multiple files to be selected.
             */
            get select_multiple(): boolean;
            set select_multiple(val: boolean);
            /**
             * Whether to allow multiple files to be selected.
             */
            get selectMultiple(): boolean;
            set selectMultiple(val: boolean);
            /**
             * A `GListModel` containing the shortcut folders that have been
             * added with gtk_file_chooser_add_shortcut_folder().
             *
             * The returned object should not be modified. It may
             * or may not be updated for later changes.
             */
            get shortcut_folders(): Gio.ListModel;
            /**
             * A `GListModel` containing the shortcut folders that have been
             * added with gtk_file_chooser_add_shortcut_folder().
             *
             * The returned object should not be modified. It may
             * or may not be updated for later changes.
             */
            get shortcutFolders(): Gio.ListModel;

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Adds a 'choice' to the file chooser.
             *
             * This is typically implemented as a combobox or, for boolean choices,
             * as a checkbutton. You can select a value using
             * [method`Gtk`.FileChooser.set_choice] before the dialog is shown,
             * and you can obtain the user-selected value in the
             * [signal`Gtk`.Dialog::response] signal handler using
             * [method`Gtk`.FileChooser.get_choice].
             * @param id id for the added choice
             * @param label user-visible label for the added choice
             * @param options ids for the options of the choice, or %NULL for a boolean choice
             * @param option_labels user-visible labels for the options, must be the same length as @options
             */
            add_choice(id: string, label: string, options?: string[] | null, option_labels?: string[] | null): void;
            /**
             * Adds `filter` to the list of filters that the user can select between.
             *
             * When a filter is selected, only files that are passed by that
             * filter are displayed.
             *
             * Note that the `chooser` takes ownership of the filter if it is floating,
             * so you have to ref and sink it if you want to keep a reference.
             * @param filter a `GtkFileFilter`
             */
            add_filter(filter: FileFilter): void;
            /**
             * Adds a folder to be displayed with the shortcut folders
             * in a file chooser.
             * @param folder a `GFile` for the folder to add
             * @returns %TRUE if the folder could be added successfully,   %FALSE otherwise.
             */
            add_shortcut_folder(folder: Gio.File): boolean;
            /**
             * Gets the type of operation that the file chooser is performing.
             * @returns the action that the file selector is performing
             */
            get_action(): FileChooserAction;
            /**
             * Gets the currently selected option in the 'choice' with the given ID.
             * @param id the ID of the choice to get
             * @returns the ID of the currently selected option
             */
            get_choice(id: string): string | null;
            /**
             * Gets whether file chooser will offer to create new folders.
             * @returns %TRUE if the Create Folder button should be displayed.
             */
            get_create_folders(): boolean;
            /**
             * Gets the current folder of `chooser` as `GFile`.
             * @returns the `GFile` for the current folder.
             */
            get_current_folder(): Gio.File | null;
            /**
             * Gets the current name in the file selector, as entered by the user.
             *
             * This is meant to be used in save dialogs, to get the currently typed
             * filename when the file itself does not exist yet.
             * @returns The raw text from the file chooser’s “Name” entry. Free with   g_free(). Note that this string is not a full pathname or URI; it is   whatever the contents of the entry are. Note also that this string is   in UTF-8 encoding, which is not necessarily the system’s encoding for   filenames.
             */
            get_current_name(): string | null;
            /**
             * Gets the `GFile` for the currently selected file in
             * the file selector.
             *
             * If multiple files are selected, one of the files will be
             * returned at random.
             *
             * If the file chooser is in folder mode, this function returns
             * the selected folder.
             * @returns a selected `GFile`. You own the   returned file; use g_object_unref() to release it.
             */
            get_file(): Gio.File | null;
            /**
             * Lists all the selected files and subfolders in the current folder
             * of `chooser` as `GFile`.
             * @returns a list model containing a `GFile` for each   selected file and subfolder in the current folder. Free the returned   list with g_object_unref().
             */
            get_files(): Gio.ListModel;
            /**
             * Gets the current filter.
             * @returns the current filter
             */
            get_filter(): FileFilter | null;
            /**
             * Gets the current set of user-selectable filters, as a list model.
             *
             * See [method`Gtk`.FileChooser.add_filter] and
             * [method`Gtk`.FileChooser.remove_filter] for changing individual filters.
             *
             * You should not modify the returned list model. Future changes to
             * `chooser` may or may not affect the returned model.
             * @returns a `GListModel` containing the current set   of user-selectable filters.
             */
            get_filters(): Gio.ListModel;
            /**
             * Gets whether multiple files can be selected in the file
             * chooser.
             * @returns %TRUE if multiple files can be selected.
             */
            get_select_multiple(): boolean;
            /**
             * Queries the list of shortcut folders in the file chooser.
             *
             * You should not modify the returned list model. Future changes to
             * `chooser` may or may not affect the returned model.
             * @returns A list model of `GFile`s
             */
            get_shortcut_folders(): Gio.ListModel;
            /**
             * Removes a 'choice' that has been added with gtk_file_chooser_add_choice().
             * @param id the ID of the choice to remove
             */
            remove_choice(id: string): void;
            /**
             * Removes `filter` from the list of filters that the user can select between.
             * @param filter a `GtkFileFilter`
             */
            remove_filter(filter: FileFilter): void;
            /**
             * Removes a folder from the shortcut folders in a file chooser.
             * @param folder a `GFile` for the folder to remove
             * @returns %TRUE if the folder could be removed successfully,   %FALSE otherwise.
             */
            remove_shortcut_folder(folder: Gio.File): boolean;
            /**
             * Sets the type of operation that the chooser is performing.
             *
             * The user interface is adapted to suit the selected action.
             *
             * For example, an option to create a new folder might be shown
             * if the action is %GTK_FILE_CHOOSER_ACTION_SAVE but not if the
             * action is %GTK_FILE_CHOOSER_ACTION_OPEN.
             * @param action the action that the file selector is performing
             */
            set_action(action: FileChooserAction | null): void;
            /**
             * Selects an option in a 'choice' that has been added with
             * gtk_file_chooser_add_choice().
             *
             * For a boolean choice, the possible options are "true" and "false".
             * @param id the ID of the choice to set
             * @param option the ID of the option to select
             */
            set_choice(id: string, option: string): void;
            /**
             * Sets whether file chooser will offer to create new folders.
             *
             * This is only relevant if the action is not set to be
             * %GTK_FILE_CHOOSER_ACTION_OPEN.
             * @param create_folders %TRUE if the Create Folder button should be displayed
             */
            set_create_folders(create_folders: boolean): void;
            /**
             * Sets the current folder for `chooser` from a `GFile`.
             * @param file the `GFile` for the new folder
             * @returns %TRUE if the folder could be changed successfully, %FALSE   otherwise.
             */
            set_current_folder(file?: Gio.File | null): boolean;
            /**
             * Sets the current name in the file selector, as if entered
             * by the user.
             *
             * Note that the name passed in here is a UTF-8 string rather
             * than a filename. This function is meant for such uses as a
             * suggested name in a “Save As...” dialog.  You can pass
             * “Untitled.doc” or a similarly suitable suggestion for the `name`.
             *
             * If you want to preselect a particular existing file, you should
             * use [method`Gtk`.FileChooser.set_file] instead.
             *
             * Please see the documentation for those functions for an example
             * of using [method`Gtk`.FileChooser.set_current_name] as well.
             * @param name the filename to use, as a UTF-8 string
             */
            set_current_name(name: string): void;
            /**
             * Sets `file` as the current filename for the file chooser.
             *
             * This includes changing to the file’s parent folder and actually selecting
             * the file in list. If the `chooser` is in %GTK_FILE_CHOOSER_ACTION_SAVE mode,
             * the file’s base name will also appear in the dialog’s file name entry.
             *
             * If the file name isn’t in the current folder of `chooser,` then the current
             * folder of `chooser` will be changed to the folder containing `file`.
             *
             * Note that the file must exist, or nothing will be done except
             * for the directory change.
             *
             * If you are implementing a save dialog, you should use this function if
             * you already have a file name to which the user may save; for example,
             * when the user opens an existing file and then does “Save As…”. If you
             * don’t have a file name already — for example, if the user just created
             * a new file and is saving it for the first time, do not call this function.
             *
             * Instead, use something similar to this:
             *
             * ```c
             * static void
             * prepare_file_chooser (GtkFileChooser *chooser,
             *                       GFile          *existing_file)
             * {
             *   gboolean document_is_new = (existing_file == NULL);
             *
             *   if (document_is_new)
             *     {
             *       GFile *default_file_for_saving = g_file_new_for_path ("./out.txt");
             *       // the user just created a new document
             *       gtk_file_chooser_set_current_folder (chooser, default_file_for_saving, NULL);
             *       gtk_file_chooser_set_current_name (chooser, "Untitled document");
             *       g_object_unref (default_file_for_saving);
             *     }
             *   else
             *     {
             *       // the user edited an existing document
             *       gtk_file_chooser_set_file (chooser, existing_file, NULL);
             *     }
             * }
             * ```
             * @param file the `GFile` to set as current
             * @returns Not useful
             */
            set_file(file: Gio.File): boolean;
            /**
             * Sets the current filter.
             *
             * Only the files that pass the filter will be displayed.
             * If the user-selectable list of filters is non-empty, then
             * the filter should be one of the filters in that list.
             *
             * Setting the current filter when the list of filters is
             * empty is useful if you want to restrict the displayed
             * set of files without letting the user change it.
             * @param filter a `GtkFileFilter`
             */
            set_filter(filter: FileFilter): void;
            /**
             * Sets whether multiple files can be selected in the file chooser.
             *
             * This is only relevant if the action is set to be
             * %GTK_FILE_CHOOSER_ACTION_OPEN or
             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER.
             * @param select_multiple %TRUE if multiple files can be selected.
             */
            set_select_multiple(select_multiple: boolean): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace FileDialog {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                accept_label: string;
                acceptLabel: string;
                default_filter: FileFilter;
                defaultFilter: FileFilter;
                filters: Gio.ListModel;
                initial_file: Gio.File;
                initialFile: Gio.File;
                initial_folder: Gio.File;
                initialFolder: Gio.File;
                initial_name: string;
                initialName: string;
                modal: boolean;
                title: string;
            }
        }

        /**
         * A `GtkFileDialog` object collects the arguments that
         * are needed to present a file chooser dialog to the
         * user, such as a title for the dialog and whether it
         * should be modal.
         *
         * The dialog is shown with [method`Gtk`.FileDialog.open],
         * [method`Gtk`.FileDialog.save], etc.
         */
        class FileDialog extends GObject.Object {
            static $gtype: GObject.GType<FileDialog>;

            // Properties

            /**
             * Label for the file chooser's accept button.
             */
            get accept_label(): string;
            set accept_label(val: string);
            /**
             * Label for the file chooser's accept button.
             */
            get acceptLabel(): string;
            set acceptLabel(val: string);
            /**
             * The default filter, that is, the filter that is initially
             * active in the file chooser dialog.
             *
             * If the default filter is %NULL, the first filter of [property`Gtk`.FileDialog:filters]
             * is used as the default filter. If that property contains no filter, the dialog will
             * be unfiltered.
             *
             * If [property`Gtk`.FileDialog:filters] is not %NULL, the default filter should be part
             * of the list. If it is not, the dialog may choose to not make it available.
             */
            get default_filter(): FileFilter;
            set default_filter(val: FileFilter);
            /**
             * The default filter, that is, the filter that is initially
             * active in the file chooser dialog.
             *
             * If the default filter is %NULL, the first filter of [property`Gtk`.FileDialog:filters]
             * is used as the default filter. If that property contains no filter, the dialog will
             * be unfiltered.
             *
             * If [property`Gtk`.FileDialog:filters] is not %NULL, the default filter should be part
             * of the list. If it is not, the dialog may choose to not make it available.
             */
            get defaultFilter(): FileFilter;
            set defaultFilter(val: FileFilter);
            /**
             * The list of filters.
             *
             * See [property`Gtk`.FileDialog:default-filter] about how those two properties interact.
             */
            get filters(): Gio.ListModel;
            set filters(val: Gio.ListModel);
            /**
             * The initial file, that is, the file that is initially selected
             * in the file chooser dialog
             *
             * This is a utility property that sets both [property`Gtk`.FileDialog:initial-folder] and
             * [property`Gtk`.FileDialog:initial-name].
             */
            get initial_file(): Gio.File;
            set initial_file(val: Gio.File);
            /**
             * The initial file, that is, the file that is initially selected
             * in the file chooser dialog
             *
             * This is a utility property that sets both [property`Gtk`.FileDialog:initial-folder] and
             * [property`Gtk`.FileDialog:initial-name].
             */
            get initialFile(): Gio.File;
            set initialFile(val: Gio.File);
            /**
             * The initial folder, that is, the directory that is initially
             * opened in the file chooser dialog
             */
            get initial_folder(): Gio.File;
            set initial_folder(val: Gio.File);
            /**
             * The initial folder, that is, the directory that is initially
             * opened in the file chooser dialog
             */
            get initialFolder(): Gio.File;
            set initialFolder(val: Gio.File);
            /**
             * The initial name, that is, the filename that is initially
             * selected in the file chooser dialog.
             */
            get initial_name(): string;
            set initial_name(val: string);
            /**
             * The initial name, that is, the filename that is initially
             * selected in the file chooser dialog.
             */
            get initialName(): string;
            set initialName(val: string);
            /**
             * Whether the file chooser dialog is modal.
             */
            get modal(): boolean;
            set modal(val: boolean);
            /**
             * A title that may be shown on the file chooser dialog.
             */
            get title(): string;
            set title(val: string);

            // Constructors

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

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

            static ['new'](): FileDialog;

            // Methods

            /**
             * Retrieves the text used by the dialog on its accept button.
             * @returns the label shown on the file chooser's accept button.
             */
            get_accept_label(): string | null;
            /**
             * Gets the filter that will be selected by default
             * in the file chooser dialog.
             * @returns the current filter
             */
            get_default_filter(): FileFilter | null;
            /**
             * Gets the filters that will be offered to the user
             * in the file chooser dialog.
             * @returns the filters, as   a `GListModel` of `GtkFileFilters`
             */
            get_filters(): Gio.ListModel | null;
            /**
             * Gets the file that will be initially selected in
             * the file chooser dialog.
             * @returns the file
             */
            get_initial_file(): Gio.File | null;
            /**
             * Gets the folder that will be set as the
             * initial folder in the file chooser dialog.
             * @returns the folder
             */
            get_initial_folder(): Gio.File | null;
            /**
             * Gets the name for the file that should be initially set.
             * @returns the name
             */
            get_initial_name(): string | null;
            /**
             * Returns whether the file chooser dialog
             * blocks interaction with the parent window
             * while it is presented.
             * @returns `TRUE` if the file chooser dialog is modal
             */
            get_modal(): boolean;
            /**
             * Returns the title that will be shown on the
             * file chooser dialog.
             * @returns the title
             */
            get_title(): string;
            /**
             * This function initiates a file selection operation by
             * presenting a file chooser dialog to the user.
             *
             * The `callback` will be called when the dialog is dismissed.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             */
            open(parent?: Window | null, cancellable?: Gio.Cancellable | null): Promise<Gio.File | null>;
            /**
             * This function initiates a file selection operation by
             * presenting a file chooser dialog to the user.
             *
             * The `callback` will be called when the dialog is dismissed.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            open(
                parent: Window | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * This function initiates a file selection operation by
             * presenting a file chooser dialog to the user.
             *
             * The `callback` will be called when the dialog is dismissed.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            open(
                parent?: Window | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<Gio.File | null> | void;
            /**
             * Finishes the [method`Gtk`.FileDialog.open] call and
             * returns the resulting file.
             * @param result a `GAsyncResult`
             * @returns the file that was selected.   Otherwise, `NULL` is returned and @error is set
             */
            open_finish(result: Gio.AsyncResult): Gio.File | null;
            /**
             * This function initiates a multi-file selection operation by
             * presenting a file chooser dialog to the user.
             *
             * The file chooser will initially be opened in the directory
             * [property`Gtk`.FileDialog:initial-folder].
             *
             * The `callback` will be called when the dialog is dismissed.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             */
            open_multiple(parent?: Window | null, cancellable?: Gio.Cancellable | null): Promise<Gio.ListModel | null>;
            /**
             * This function initiates a multi-file selection operation by
             * presenting a file chooser dialog to the user.
             *
             * The file chooser will initially be opened in the directory
             * [property`Gtk`.FileDialog:initial-folder].
             *
             * The `callback` will be called when the dialog is dismissed.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            open_multiple(
                parent: Window | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * This function initiates a multi-file selection operation by
             * presenting a file chooser dialog to the user.
             *
             * The file chooser will initially be opened in the directory
             * [property`Gtk`.FileDialog:initial-folder].
             *
             * The `callback` will be called when the dialog is dismissed.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            open_multiple(
                parent?: Window | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<Gio.ListModel | null> | void;
            /**
             * Finishes the [method`Gtk`.FileDialog.open] call and
             * returns the resulting files in a `GListModel`.
             * @param result a `GAsyncResult`
             * @returns the file that was selected,   as a `GListModel` of `GFiles`. Otherwise, `NULL` is returned   and @error is set
             */
            open_multiple_finish(result: Gio.AsyncResult): Gio.ListModel | null;
            /**
             * This function initiates a file save operation by
             * presenting a file chooser dialog to the user.
             *
             * The `callback` will be called when the dialog is dismissed.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             */
            save(parent?: Window | null, cancellable?: Gio.Cancellable | null): Promise<Gio.File | null>;
            /**
             * This function initiates a file save operation by
             * presenting a file chooser dialog to the user.
             *
             * The `callback` will be called when the dialog is dismissed.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            save(
                parent: Window | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * This function initiates a file save operation by
             * presenting a file chooser dialog to the user.
             *
             * The `callback` will be called when the dialog is dismissed.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            save(
                parent?: Window | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<Gio.File | null> | void;
            /**
             * Finishes the [method`Gtk`.FileDialog.save] call and
             * returns the resulting file.
             * @param result a `GAsyncResult`
             * @returns the file that was selected.   Otherwise, `NULL` is returned and @error is set
             */
            save_finish(result: Gio.AsyncResult): Gio.File | null;
            /**
             * This function initiates a directory selection operation by
             * presenting a file chooser dialog to the user.
             *
             * If you pass `initial_folder,` the file chooser will initially be
             * opened in the parent directory of that folder, otherwise, it
             * will be in the directory [property`Gtk`.FileDialog:initial-folder].
             *
             * The `callback` will be called when the dialog is dismissed.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             */
            select_folder(parent?: Window | null, cancellable?: Gio.Cancellable | null): Promise<Gio.File | null>;
            /**
             * This function initiates a directory selection operation by
             * presenting a file chooser dialog to the user.
             *
             * If you pass `initial_folder,` the file chooser will initially be
             * opened in the parent directory of that folder, otherwise, it
             * will be in the directory [property`Gtk`.FileDialog:initial-folder].
             *
             * The `callback` will be called when the dialog is dismissed.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            select_folder(
                parent: Window | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * This function initiates a directory selection operation by
             * presenting a file chooser dialog to the user.
             *
             * If you pass `initial_folder,` the file chooser will initially be
             * opened in the parent directory of that folder, otherwise, it
             * will be in the directory [property`Gtk`.FileDialog:initial-folder].
             *
             * The `callback` will be called when the dialog is dismissed.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            select_folder(
                parent?: Window | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<Gio.File | null> | void;
            /**
             * Finishes the [method`Gtk`.FileDialog.select_folder] call and
             * returns the resulting file.
             * @param result a `GAsyncResult`
             * @returns the file that was selected.   Otherwise, `NULL` is returned and @error is set
             */
            select_folder_finish(result: Gio.AsyncResult): Gio.File | null;
            /**
             * This function initiates a multi-directory selection operation by
             * presenting a file chooser dialog to the user.
             *
             * The file chooser will initially be opened in the directory
             * [property`Gtk`.FileDialog:initial-folder].
             *
             * The `callback` will be called when the dialog is dismissed.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             */
            select_multiple_folders(
                parent?: Window | null,
                cancellable?: Gio.Cancellable | null,
            ): Promise<Gio.ListModel | null>;
            /**
             * This function initiates a multi-directory selection operation by
             * presenting a file chooser dialog to the user.
             *
             * The file chooser will initially be opened in the directory
             * [property`Gtk`.FileDialog:initial-folder].
             *
             * The `callback` will be called when the dialog is dismissed.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            select_multiple_folders(
                parent: Window | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * This function initiates a multi-directory selection operation by
             * presenting a file chooser dialog to the user.
             *
             * The file chooser will initially be opened in the directory
             * [property`Gtk`.FileDialog:initial-folder].
             *
             * The `callback` will be called when the dialog is dismissed.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            select_multiple_folders(
                parent?: Window | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<Gio.ListModel | null> | void;
            /**
             * Finishes the [method`Gtk`.FileDialog.select_multiple_folders]
             * call and returns the resulting files in a `GListModel`.
             * @param result a `GAsyncResult`
             * @returns the file that was selected,   as a `GListModel` of `GFiles`. Otherwise, `NULL` is returned   and @error is set
             */
            select_multiple_folders_finish(result: Gio.AsyncResult): Gio.ListModel | null;
            /**
             * Sets the label shown on the file chooser's accept button.
             *
             * Leaving the accept label unset or setting it as `NULL` will fall back to
             * a default label, depending on what API is used to launch the file dialog.
             * @param accept_label the new accept label
             */
            set_accept_label(accept_label?: string | null): void;
            /**
             * Sets the filter that will be selected by default
             * in the file chooser dialog.
             *
             * If set to %NULL, the first item in [property`Gtk`.FileDialog:filters]
             * will be used as the default filter. If that list is empty, the dialog
             * will be unfiltered.
             * @param filter a `GtkFileFilter`
             */
            set_default_filter(filter?: FileFilter | null): void;
            /**
             * Sets the filters that will be offered to the user
             * in the file chooser dialog.
             * @param filters a `GListModel` of `GtkFileFilters`
             */
            set_filters(filters?: Gio.ListModel | null): void;
            /**
             * Sets the file that will be initially selected in
             * the file chooser dialog.
             *
             * This function is a shortcut for calling both
             * gtk_file_dialog_set_initial_folder() and
             * gtk_file_dialog_set_initial_name() with the directory and
             * name of `file` respectively.
             * @param file a `GFile`
             */
            set_initial_file(file?: Gio.File | null): void;
            /**
             * Sets the folder that will be set as the
             * initial folder in the file chooser dialog.
             * @param folder a `GFile`
             */
            set_initial_folder(folder?: Gio.File | null): void;
            /**
             * Sets the name for the file that should be initially set.
             * For saving dialogs, this will usually be pre-entered into the name field.
             *
             * If a file with this name already exists in the directory set via
             * [property`Gtk`.FileDialog:initial-folder], the dialog should preselect it.
             * @param name a UTF8 string
             */
            set_initial_name(name?: string | null): void;
            /**
             * Sets whether the file chooser dialog
             * blocks interaction with the parent window
             * while it is presented.
             * @param modal the new value
             */
            set_modal(modal: boolean): void;
            /**
             * Sets the title that will be shown on the
             * file chooser dialog.
             * @param title the new title
             */
            set_title(title: string): void;
        }

        namespace FileFilter {
            // Constructor properties interface

            interface ConstructorProps extends Filter.ConstructorProps, Buildable.ConstructorProps {
                mime_types: string[];
                mimeTypes: string[];
                name: string;
                patterns: string[];
                suffixes: string[];
            }
        }

        /**
         * `GtkFileFilter` filters files by name or mime type.
         *
         * `GtkFileFilter` can be used to restrict the files being shown in a
         * `GtkFileChooser`. Files can be filtered based on their name (with
         * [method`Gtk`.FileFilter.add_pattern] or [method`Gtk`.FileFilter.add_suffix])
         * or on their mime type (with [method`Gtk`.FileFilter.add_mime_type]).
         *
         * Filtering by mime types handles aliasing and subclassing of mime
         * types; e.g. a filter for text/plain also matches a file with mime
         * type application/rtf, since application/rtf is a subclass of
         * text/plain. Note that `GtkFileFilter` allows wildcards for the
         * subtype of a mime type, so you can e.g. filter for image/\*.
         *
         * Normally, file filters are used by adding them to a `GtkFileChooser`
         * (see [method`Gtk`.FileChooser.add_filter]), but it is also possible to
         * manually use a file filter on any [class`Gtk`.FilterListModel] containing
         * `GFileInfo` objects.
         *
         * # GtkFileFilter as GtkBuildable
         *
         * The `GtkFileFilter` implementation of the `GtkBuildable` interface
         * supports adding rules using the `<mime-types>` and `<patterns>` and
         * `<suffixes>` elements and listing the rules within. Specifying a
         * `<mime-type>` or `<pattern>` or `<suffix>` has the same effect as
         * as calling
         * [method`Gtk`.FileFilter.add_mime_type] or
         * [method`Gtk`.FileFilter.add_pattern] or
         * [method`Gtk`.FileFilter.add_suffix].
         *
         * An example of a UI definition fragment specifying `GtkFileFilter`
         * rules:
         * ```xml
         * <object class="GtkFileFilter">
         *   <property name="name" translatable="yes">Text and Images</property>
         *   <mime-types>
         *     <mime-type>text/plain</mime-type>
         *     <mime-type>image/ *</mime-type>
         *   </mime-types>
         *   <patterns>
         *     <pattern>*.txt</pattern>
         *   </patterns>
         *   <suffixes>
         *     <suffix>png</suffix>
         *   </suffixes>
         * </object>
         * ```
         */
        class FileFilter extends Filter implements Buildable {
            static $gtype: GObject.GType<FileFilter>;

            // Properties

            /**
             * The MIME types that this filter matches.
             */
            set mime_types(val: string[]);
            /**
             * The MIME types that this filter matches.
             */
            set mimeTypes(val: string[]);
            /**
             * The human-readable name of the filter.
             *
             * This is the string that will be displayed in the file chooser
             * user interface if there is a selectable list of filters.
             */
            get name(): string;
            set name(val: string);
            /**
             * The patterns that this filter matches.
             */
            set patterns(val: string[]);
            /**
             * The suffixes that this filter matches.
             */
            set suffixes(val: string[]);

            // Constructors

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

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

            static ['new'](): FileFilter;

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

            // Methods

            /**
             * Adds a rule allowing a given mime type to `filter`.
             * @param mime_type name of a MIME type
             */
            add_mime_type(mime_type: string): void;
            /**
             * Adds a rule allowing a shell style glob to a filter.
             *
             * Note that it depends on the platform whether pattern
             * matching ignores case or not. On Windows, it does, on
             * other platforms, it doesn't.
             * @param pattern a shell style glob
             */
            add_pattern(pattern: string): void;
            /**
             * Adds a rule allowing image files in the formats supported
             * by GdkPixbuf.
             *
             * This is equivalent to calling [method`Gtk`.FileFilter.add_mime_type]
             * for all the supported mime types.
             */
            add_pixbuf_formats(): void;
            /**
             * Adds a suffix match rule to a filter.
             *
             * This is similar to adding a match for the pattern
             * "*.`suffix"`.
             *
             * In contrast to pattern matches, suffix matches
             * are *always* case-insensitive.
             * @param suffix filename suffix to match
             */
            add_suffix(suffix: string): void;
            /**
             * Gets the attributes that need to be filled in for the `GFileInfo`
             * passed to this filter.
             *
             * This function will not typically be used by applications;
             * it is intended principally for use in the implementation
             * of `GtkFileChooser`.
             * @returns the attributes
             */
            get_attributes(): string[];
            /**
             * Gets the human-readable name for the filter.
             *
             * See [method`Gtk`.FileFilter.set_name].
             * @returns The human-readable name of the filter
             */
            get_name(): string | null;
            /**
             * Sets a human-readable name of the filter.
             *
             * This is the string that will be displayed in the file chooser
             * if there is a selectable list of filters.
             * @param name the human-readable-name for the filter, or %NULL   to remove any existing name.
             */
            set_name(name?: string | null): void;
            /**
             * Serialize a file filter to an `a{sv}` variant.
             * @returns a new, floating, `GVariant`
             */
            to_gvariant(): GLib.Variant;

            // Inherited methods
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace FileLauncher {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                always_ask: boolean;
                alwaysAsk: boolean;
                file: Gio.File;
                writable: boolean;
            }
        }

        /**
         * A `GtkFileLauncher` object collects the arguments that are needed to open a
         * file with an application.
         *
         * Depending on system configuration, user preferences and available APIs, this
         * may or may not show an app chooser dialog or launch the default application
         * right away.
         *
         * The operation is started with the [method`Gtk`.FileLauncher.launch] function.
         *
         * To launch uris that don't represent files, use [class`Gtk`.UriLauncher].
         */
        class FileLauncher extends GObject.Object {
            static $gtype: GObject.GType<FileLauncher>;

            // Properties

            /**
             * Whether to ask the user to choose an app for opening the file. If `FALSE`,
             * the file might be opened with a default app or the previous choice.
             */
            get always_ask(): boolean;
            set always_ask(val: boolean);
            /**
             * Whether to ask the user to choose an app for opening the file. If `FALSE`,
             * the file might be opened with a default app or the previous choice.
             */
            get alwaysAsk(): boolean;
            set alwaysAsk(val: boolean);
            /**
             * The file to launch.
             */
            get file(): Gio.File;
            set file(val: Gio.File);
            /**
             * Whether to make the file writable for the handler.
             */
            get writable(): boolean;
            set writable(val: boolean);

            // Constructors

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

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

            static ['new'](file?: Gio.File | null): FileLauncher;

            // Methods

            /**
             * Returns whether to ask the user to choose an app for opening the file.
             * @returns `TRUE` if always asking for app
             */
            get_always_ask(): boolean;
            /**
             * Gets the file that will be opened.
             * @returns the file
             */
            get_file(): Gio.File | null;
            /**
             * Returns whether to make the file writable for the handler.
             * @returns `TRUE` if the file will be made writable
             */
            get_writable(): boolean;
            /**
             * Launch an application to open the file.
             *
             * This may present an app chooser dialog to the user.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             */
            launch(parent?: Window | null, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Launch an application to open the file.
             *
             * This may present an app chooser dialog to the user.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            launch(
                parent: Window | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Launch an application to open the file.
             *
             * This may present an app chooser dialog to the user.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            launch(
                parent?: Window | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes the [method`Gtk`.FileLauncher.launch] call and
             * returns the result.
             * @param result a `GAsyncResult`
             * @returns `TRUE` if an application was launched,     or `FALSE` and @error is set
             */
            launch_finish(result: Gio.AsyncResult): boolean;
            /**
             * Launch a file manager to show the file in its parent directory.
             *
             * This is only supported native files. It will fail if `file`
             * is e.g. a http:// uri.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             */
            open_containing_folder(parent?: Window | null, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Launch a file manager to show the file in its parent directory.
             *
             * This is only supported native files. It will fail if `file`
             * is e.g. a http:// uri.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            open_containing_folder(
                parent: Window | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Launch a file manager to show the file in its parent directory.
             *
             * This is only supported native files. It will fail if `file`
             * is e.g. a http:// uri.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            open_containing_folder(
                parent?: Window | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes the [method`Gtk`.FileLauncher.open_containing_folder]
             * call and returns the result.
             * @param result a `GAsyncResult`
             * @returns `TRUE` if an application was launched,     or `FALSE` and @error is set
             */
            open_containing_folder_finish(result: Gio.AsyncResult): boolean;
            /**
             * Sets whether to awlays ask the user to choose an app for opening the file.
             * If `FALSE`, the file might be opened with a default app or the previous choice.
             * @param always_ask a `gboolean`
             */
            set_always_ask(always_ask: boolean): void;
            /**
             * Sets the file that will be opened.
             * @param file a `GFile`
             */
            set_file(file?: Gio.File | null): void;
            /**
             * Sets whether to make the file writable for the handler.
             * @param writable a `gboolean`
             */
            set_writable(writable: boolean): void;
        }

        namespace Filter {
            // Signal callback interfaces

            interface Changed {
                (change: FilterChange): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * A `GtkFilter` object describes the filtering to be performed by a
         * [class`Gtk`.FilterListModel].
         *
         * The model will use the filter to determine if it should include items
         * or not by calling [method`Gtk`.Filter.match] for each item and only
         * keeping the ones that the function returns %TRUE for.
         *
         * Filters may change what items they match through their lifetime. In that
         * case, they will emit the [signal`Gtk`.Filter::changed] signal to notify
         * that previous filter results are no longer valid and that items should
         * be checked again via [method`Gtk`.Filter.match].
         *
         * GTK provides various pre-made filter implementations for common filtering
         * operations. These filters often include properties that can be linked to
         * various widgets to easily allow searches.
         *
         * However, in particular for large lists or complex search methods, it is
         * also possible to subclass `GtkFilter` and provide one's own filter.
         */
        class Filter extends GObject.Object {
            static $gtype: GObject.GType<Filter>;

            // Constructors

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

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

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'changed', callback: (_source: this, change: FilterChange) => void): number;
            connect_after(signal: 'changed', callback: (_source: this, change: FilterChange) => void): number;
            emit(signal: 'changed', change: FilterChange): void;

            // Virtual methods

            /**
             * Gets the known strictness of `filters`.
             *
             * If the strictness is not known, %GTK_FILTER_MATCH_SOME is returned.
             *
             * This value may change after emission of the [signal`Gtk`.Filter::changed]
             * signal.
             *
             * This function is meant purely for optimization purposes, filters can
             * choose to omit implementing it, but `GtkFilterListModel` uses it.
             */
            vfunc_get_strictness(): FilterMatch;
            /**
             * Checks if the given `item` is matched by the filter or not.
             * @param item The item to check
             */
            vfunc_match(item?: GObject.Object | null): boolean;

            // Methods

            /**
             * Notifies all users of the filter that it has changed.
             *
             * This emits the [signal`Gtk`.Filter::changed] signal. Users
             * of the filter should then check items again via
             * [method`Gtk`.Filter.match].
             *
             * Depending on the `change` parameter, not all items need to
             * be changed, but only some. Refer to the [enum`Gtk`.FilterChange]
             * documentation for details.
             *
             * This function is intended for implementers of `GtkFilter`
             * subclasses and should not be called from other functions.
             * @param change How the filter changed
             */
            changed(change: FilterChange | null): void;
            /**
             * Gets the known strictness of `filters`.
             *
             * If the strictness is not known, %GTK_FILTER_MATCH_SOME is returned.
             *
             * This value may change after emission of the [signal`Gtk`.Filter::changed]
             * signal.
             *
             * This function is meant purely for optimization purposes, filters can
             * choose to omit implementing it, but `GtkFilterListModel` uses it.
             * @returns the strictness of @self
             */
            get_strictness(): FilterMatch;
            /**
             * Checks if the given `item` is matched by the filter or not.
             * @param item The item to check
             * @returns %TRUE if the filter matches the item and a filter model should   keep it, %FALSE if not.
             */
            match(item: GObject.Object): boolean;
        }

        namespace FilterListModel {
            // Constructor properties interface

            interface ConstructorProps<A extends GObject.Object = GObject.Object>
                extends GObject.Object.ConstructorProps,
                    Gio.ListModel.ConstructorProps,
                    SectionModel.ConstructorProps {
                filter: Filter;
                incremental: boolean;
                item_type: GObject.GType;
                itemType: GObject.GType;
                model: Gio.ListModel;
                n_items: number;
                nItems: number;
                pending: number;
            }
        }

        /**
         * `GtkFilterListModel` is a list model that filters the elements of
         * the underlying model according to a `GtkFilter`.
         *
         * It hides some elements from the other model according to
         * criteria given by a `GtkFilter`.
         *
         * The model can be set up to do incremental filtering, so that
         * filtering long lists doesn't block the UI. See
         * [method`Gtk`.FilterListModel.set_incremental] for details.
         *
         * `GtkFilterListModel` passes through sections from the underlying model.
         */
        class FilterListModel<A extends GObject.Object = GObject.Object>
            extends GObject.Object
            implements Gio.ListModel<A>, SectionModel
        {
            static $gtype: GObject.GType<FilterListModel>;

            // Properties

            /**
             * The filter for this model.
             */
            get filter(): Filter;
            set filter(val: Filter);
            /**
             * If the model should filter items incrementally.
             */
            get incremental(): boolean;
            set incremental(val: boolean);
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get item_type(): GObject.GType;
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get itemType(): GObject.GType;
            /**
             * The model being filtered.
             */
            get model(): Gio.ListModel;
            set model(val: Gio.ListModel);
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get n_items(): number;
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get nItems(): number;
            /**
             * Number of items not yet filtered.
             */
            get pending(): number;

            // Constructors

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

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

            static ['new'](model?: Gio.ListModel | null, filter?: Filter | null): FilterListModel;

            // Methods

            /**
             * Gets the `GtkFilter` currently set on `self`.
             * @returns The filter currently in use
             */
            get_filter(): Filter | null;
            /**
             * Returns whether incremental filtering is enabled.
             *
             * See [method`Gtk`.FilterListModel.set_incremental].
             * @returns %TRUE if incremental filtering is enabled
             */
            get_incremental(): boolean;
            /**
             * Gets the model currently filtered or %NULL if none.
             * @returns The model that gets filtered
             */
            get_model(): Gio.ListModel | null;
            /**
             * Returns the number of items that have not been filtered yet.
             *
             * You can use this value to check if `self` is busy filtering by
             * comparing the return value to 0 or you can compute the percentage
             * of the filter remaining by dividing the return value by the total
             * number of items in the underlying model:
             *
             * ```c
             * pending = gtk_filter_list_model_get_pending (self);
             * model = gtk_filter_list_model_get_model (self);
             * percentage = pending / (double) g_list_model_get_n_items (model);
             * ```
             *
             * If no filter operation is ongoing - in particular when
             * [property`Gtk`.FilterListModel:incremental] is %FALSE - this
             * function returns 0.
             * @returns The number of items not yet filtered
             */
            get_pending(): number;
            /**
             * Sets the filter used to filter items.
             * @param filter filter to use
             */
            set_filter(filter?: Filter | null): void;
            /**
             * Sets the filter model to do an incremental sort.
             *
             * When incremental filtering is enabled, the `GtkFilterListModel` will not
             * run filters immediately, but will instead queue an idle handler that
             * incrementally filters the items and adds them to the list. This of course
             * means that items are not instantly added to the list, but only appear
             * incrementally.
             *
             * When your filter blocks the UI while filtering, you might consider
             * turning this on. Depending on your model and filters, this may become
             * interesting around 10,000 to 100,000 items.
             *
             * By default, incremental filtering is disabled.
             *
             * See [method`Gtk`.FilterListModel.get_pending] for progress information
             * about an ongoing incremental filtering operation.
             * @param incremental %TRUE to enable incremental filtering
             */
            set_incremental(incremental: boolean): void;
            /**
             * Sets the model to be filtered.
             *
             * Note that GTK makes no effort to ensure that `model` conforms to
             * the item type of `self`. It assumes that the caller knows what they
             * are doing and have set up an appropriate filter to ensure that item
             * types match.
             * @param model The model to be filtered
             */
            set_model(model?: Gio.ListModel | null): void;

            // Inherited methods
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             * @returns the #GType of the items contained in @list.
             */
            get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             * @returns the number of items in @list.
             */
            get_n_items(): number;
            /**
             * Get the item at `position`.
             *
             * If `position` is greater than the number of items in `list,` %NULL is
             * returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.
             *
             * This function is meant to be used by language bindings in place
             * of g_list_model_get_item().
             *
             * See also: g_list_model_get_n_items()
             * @param position the position of the item to fetch
             * @returns the object at @position.
             */
            get_item(position: number): A | null;
            /**
             * Emits the #GListModel::items-changed signal on `list`.
             *
             * This function should only be called by classes implementing
             * #GListModel. It has to be called after the internal representation
             * of `list` has been updated, because handlers connected to this signal
             * might query the new state of the list.
             *
             * Implementations must only make changes to the model (as visible to
             * its consumer) in places that will not cause problems for that
             * consumer.  For models that are driven directly by a write API (such
             * as #GListStore), changes can be reported in response to uses of that
             * API.  For models that represent remote data, changes should only be
             * made from a fresh mainloop dispatch.  It is particularly not
             * permitted to make changes in response to a call to the #GListModel
             * consumer API.
             *
             * Stated another way: in general, it is assumed that code making a
             * series of accesses to the model via the API, without returning to the
             * mainloop, and without calling other code, will continue to view the
             * same contents of the model.
             * @param position the position at which @list changed
             * @param removed the number of items removed
             * @param added the number of items added
             */
            items_changed(position: number, removed: number, added: number): void;
            /**
             * Get the item at `position`. If `position` is greater than the number of
             * items in `list,` %NULL is returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.  See g_list_model_get_n_items().
             *
             * The same #GObject instance may not appear more than once in a #GListModel.
             * @param position the position of the item to fetch
             */
            vfunc_get_item(position: number): A | null;
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             */
            vfunc_get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             */
            vfunc_get_n_items(): number;
            /**
             * Query the section that covers the given position. The number of
             * items in the section can be computed by `out_end - out_start`.
             *
             * If the position is larger than the number of items, a single
             * range from n_items to G_MAXUINT will be returned.
             * @param position the position of the item to query
             */
            get_section(position: number): [number, number];
            /**
             * This function emits the [signal`Gtk`.SectionModel::sections-changed]
             * signal to notify about changes to sections.
             *
             * It must cover all positions that used to be a section start or that
             * are now a section start. It does not have to cover all positions for
             * which the section has changed.
             *
             * The [signal`Gio`.ListModel::items-changed] implies the effect of the
             * [signal`Gtk`.SectionModel::sections-changed] signal for all the items
             * it covers.
             *
             * It is recommended that when changes to the items cause section changes
             * in a larger range, that the larger range is included in the emission
             * of the [signal`Gio`.ListModel::items-changed] instead of emitting
             * two signals.
             * @param position the first changed item
             * @param n_items the number of changed items
             */
            sections_changed(position: number, n_items: number): void;
            /**
             * Query the section that covers the given position. The number of
             * items in the section can be computed by `out_end - out_start`.
             *
             * If the position is larger than the number of items, a single
             * range from n_items to G_MAXUINT will be returned.
             * @param position the position of the item to query
             */
            vfunc_get_section(position: number): [number, number];
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Fixed {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {}
        }

        /**
         * `GtkFixed` places its child widgets at fixed positions and with fixed sizes.
         *
         * `GtkFixed` performs no automatic layout management.
         *
         * For most applications, you should not use this container! It keeps
         * you from having to learn about the other GTK containers, but it
         * results in broken applications.  With `GtkFixed`, the following
         * things will result in truncated text, overlapping widgets, and
         * other display bugs:
         *
         * - Themes, which may change widget sizes.
         *
         * - Fonts other than the one you used to write the app will of course
         *   change the size of widgets containing text; keep in mind that
         *   users may use a larger font because of difficulty reading the
         *   default, or they may be using a different OS that provides different fonts.
         *
         * - Translation of text into other languages changes its size. Also,
         *   display of non-English text will use a different font in many
         *   cases.
         *
         * In addition, `GtkFixed` does not pay attention to text direction and
         * thus may produce unwanted results if your app is run under right-to-left
         * languages such as Hebrew or Arabic. That is: normally GTK will order
         * containers appropriately for the text direction, e.g. to put labels to
         * the right of the thing they label when using an RTL language, but it can’t
         * do that with `GtkFixed`. So if you need to reorder widgets depending on
         * the text direction, you would need to manually detect it and adjust child
         * positions accordingly.
         *
         * Finally, fixed positioning makes it kind of annoying to add/remove
         * UI elements, since you have to reposition all the other elements. This
         * is a long-term maintenance problem for your application.
         *
         * If you know none of these things are an issue for your application,
         * and prefer the simplicity of `GtkFixed`, by all means use the
         * widget. But you should be aware of the tradeoffs.
         */
        class Fixed extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<Fixed>;

            // Constructors

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

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

            static ['new'](): Fixed;

            // Methods

            /**
             * Retrieves the translation transformation of the
             * given child `GtkWidget` in the `GtkFixed`.
             *
             * See also: [method`Gtk`.Fixed.get_child_transform].
             * @param widget a child of @fixed
             */
            get_child_position(widget: Widget): [number, number];
            /**
             * Retrieves the transformation for `widget` set using
             * gtk_fixed_set_child_transform().
             * @param widget a `GtkWidget`, child of @fixed
             * @returns a `GskTransform`
             */
            get_child_transform(widget: Widget): Gsk.Transform | null;
            /**
             * Sets a translation transformation to the given `x` and `y`
             * coordinates to the child `widget` of the `GtkFixed`.
             * @param widget the child widget
             * @param x the horizontal position to move the widget to
             * @param y the vertical position to move the widget to
             */
            move(widget: Widget, x: number, y: number): void;
            /**
             * Adds a widget to a `GtkFixed` at the given position.
             * @param widget the widget to add
             * @param x the horizontal position to place the widget at
             * @param y the vertical position to place the widget at
             */
            put(widget: Widget, x: number, y: number): void;
            /**
             * Removes a child from `fixed`.
             * @param widget the child widget to remove
             */
            remove(widget: Widget): void;
            /**
             * Sets the transformation for `widget`.
             *
             * This is a convenience function that retrieves the
             * [class`Gtk`.FixedLayoutChild] instance associated to
             * `widget` and calls [method`Gtk`.FixedLayoutChild.set_transform].
             * @param widget a `GtkWidget`, child of @fixed
             * @param transform the transformation assigned to @widget   to reset @widget's transform
             */
            set_child_transform(widget: Widget, transform?: Gsk.Transform | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace FixedLayout {
            // Constructor properties interface

            interface ConstructorProps extends LayoutManager.ConstructorProps {}
        }

        /**
         * `GtkFixedLayout` is a layout manager which can place child widgets
         * at fixed positions.
         *
         * Most applications should never use this layout manager; fixed positioning
         * and sizing requires constant recalculations on where children need to be
         * positioned and sized. Other layout managers perform this kind of work
         * internally so that application developers don't need to do it. Specifically,
         * widgets positioned in a fixed layout manager will need to take into account:
         *
         * - Themes, which may change widget sizes.
         *
         * - Fonts other than the one you used to write the app will of course
         *   change the size of widgets containing text; keep in mind that
         *   users may use a larger font because of difficulty reading the
         *   default, or they may be using a different OS that provides different
         *   fonts.
         *
         * - Translation of text into other languages changes its size. Also,
         *   display of non-English text will use a different font in many
         *   cases.
         *
         * In addition, `GtkFixedLayout` does not pay attention to text direction and
         * thus may produce unwanted results if your app is run under right-to-left
         * languages such as Hebrew or Arabic. That is: normally GTK will order
         * containers appropriately depending on the text direction, e.g. to put labels
         * to the right of the thing they label when using an RTL language;
         * `GtkFixedLayout` won't be able to do that for you.
         *
         * Finally, fixed positioning makes it kind of annoying to add/remove UI
         * elements, since you have to reposition all the other  elements. This is a
         * long-term maintenance problem for your application.
         */
        class FixedLayout extends LayoutManager {
            static $gtype: GObject.GType<FixedLayout>;

            // Constructors

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

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

            static ['new'](): FixedLayout;
        }

        namespace FixedLayoutChild {
            // Constructor properties interface

            interface ConstructorProps extends LayoutChild.ConstructorProps {
                transform: Gsk.Transform;
            }
        }

        /**
         * `GtkLayoutChild` subclass for children in a `GtkFixedLayout`.
         */
        class FixedLayoutChild extends LayoutChild {
            static $gtype: GObject.GType<FixedLayoutChild>;

            // Properties

            /**
             * The transform of the child.
             */
            get transform(): Gsk.Transform;
            set transform(val: Gsk.Transform);

            // Constructors

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

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

            // Methods

            /**
             * Retrieves the transformation of the child.
             * @returns a `GskTransform`
             */
            get_transform(): Gsk.Transform | null;
            /**
             * Sets the transformation of the child of a `GtkFixedLayout`.
             * @param transform a `GskTransform`
             */
            set_transform(transform: Gsk.Transform): void;
        }

        namespace FlattenListModel {
            // Constructor properties interface

            interface ConstructorProps<A extends GObject.Object = GObject.Object>
                extends GObject.Object.ConstructorProps,
                    Gio.ListModel.ConstructorProps,
                    SectionModel.ConstructorProps {
                item_type: GObject.GType;
                itemType: GObject.GType;
                model: Gio.ListModel;
                n_items: number;
                nItems: number;
            }
        }

        /**
         * `GtkFlattenListModel` is a list model that concatenates other list models.
         *
         * `GtkFlattenListModel` takes a list model containing list models, and flattens
         * it into a single model. Each list model becomes a section in the single model.
         */
        class FlattenListModel<A extends GObject.Object = GObject.Object>
            extends GObject.Object
            implements Gio.ListModel<A>, SectionModel
        {
            static $gtype: GObject.GType<FlattenListModel>;

            // Properties

            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get item_type(): GObject.GType;
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get itemType(): GObject.GType;
            /**
             * The model being flattened.
             */
            get model(): Gio.ListModel;
            set model(val: Gio.ListModel);
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get n_items(): number;
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get nItems(): number;

            // Constructors

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

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

            static ['new'](model?: Gio.ListModel | null): FlattenListModel;

            // Methods

            /**
             * Gets the model set via gtk_flatten_list_model_set_model().
             * @returns The model flattened by @self
             */
            get_model(): Gio.ListModel | null;
            /**
             * Returns the model containing the item at the given position.
             * @param position a position
             * @returns the model containing the item at @position
             */
            get_model_for_item(position: number): Gio.ListModel | null;
            /**
             * Sets a new model to be flattened.
             * @param model the new model
             */
            set_model(model?: Gio.ListModel | null): void;

            // Inherited methods
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             * @returns the #GType of the items contained in @list.
             */
            get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             * @returns the number of items in @list.
             */
            get_n_items(): number;
            /**
             * Get the item at `position`.
             *
             * If `position` is greater than the number of items in `list,` %NULL is
             * returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.
             *
             * This function is meant to be used by language bindings in place
             * of g_list_model_get_item().
             *
             * See also: g_list_model_get_n_items()
             * @param position the position of the item to fetch
             * @returns the object at @position.
             */
            get_item(position: number): A | null;
            /**
             * Emits the #GListModel::items-changed signal on `list`.
             *
             * This function should only be called by classes implementing
             * #GListModel. It has to be called after the internal representation
             * of `list` has been updated, because handlers connected to this signal
             * might query the new state of the list.
             *
             * Implementations must only make changes to the model (as visible to
             * its consumer) in places that will not cause problems for that
             * consumer.  For models that are driven directly by a write API (such
             * as #GListStore), changes can be reported in response to uses of that
             * API.  For models that represent remote data, changes should only be
             * made from a fresh mainloop dispatch.  It is particularly not
             * permitted to make changes in response to a call to the #GListModel
             * consumer API.
             *
             * Stated another way: in general, it is assumed that code making a
             * series of accesses to the model via the API, without returning to the
             * mainloop, and without calling other code, will continue to view the
             * same contents of the model.
             * @param position the position at which @list changed
             * @param removed the number of items removed
             * @param added the number of items added
             */
            items_changed(position: number, removed: number, added: number): void;
            /**
             * Get the item at `position`. If `position` is greater than the number of
             * items in `list,` %NULL is returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.  See g_list_model_get_n_items().
             *
             * The same #GObject instance may not appear more than once in a #GListModel.
             * @param position the position of the item to fetch
             */
            vfunc_get_item(position: number): A | null;
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             */
            vfunc_get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             */
            vfunc_get_n_items(): number;
            /**
             * Query the section that covers the given position. The number of
             * items in the section can be computed by `out_end - out_start`.
             *
             * If the position is larger than the number of items, a single
             * range from n_items to G_MAXUINT will be returned.
             * @param position the position of the item to query
             */
            get_section(position: number): [number, number];
            /**
             * This function emits the [signal`Gtk`.SectionModel::sections-changed]
             * signal to notify about changes to sections.
             *
             * It must cover all positions that used to be a section start or that
             * are now a section start. It does not have to cover all positions for
             * which the section has changed.
             *
             * The [signal`Gio`.ListModel::items-changed] implies the effect of the
             * [signal`Gtk`.SectionModel::sections-changed] signal for all the items
             * it covers.
             *
             * It is recommended that when changes to the items cause section changes
             * in a larger range, that the larger range is included in the emission
             * of the [signal`Gio`.ListModel::items-changed] instead of emitting
             * two signals.
             * @param position the first changed item
             * @param n_items the number of changed items
             */
            sections_changed(position: number, n_items: number): void;
            /**
             * Query the section that covers the given position. The number of
             * items in the section can be computed by `out_end - out_start`.
             *
             * If the position is larger than the number of items, a single
             * range from n_items to G_MAXUINT will be returned.
             * @param position the position of the item to query
             */
            vfunc_get_section(position: number): [number, number];
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace FlowBox {
            // Signal callback interfaces

            interface ActivateCursorChild {
                (): void;
            }

            interface ChildActivated {
                (child: FlowBoxChild): void;
            }

            interface MoveCursor {
                (step: MovementStep, count: number, extend: boolean, modify: boolean): boolean;
            }

            interface SelectAll {
                (): void;
            }

            interface SelectedChildrenChanged {
                (): void;
            }

            interface ToggleCursorChild {
                (): void;
            }

            interface UnselectAll {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Orientable.ConstructorProps {
                accept_unpaired_release: boolean;
                acceptUnpairedRelease: boolean;
                activate_on_single_click: boolean;
                activateOnSingleClick: boolean;
                column_spacing: number;
                columnSpacing: number;
                homogeneous: boolean;
                max_children_per_line: number;
                maxChildrenPerLine: number;
                min_children_per_line: number;
                minChildrenPerLine: number;
                row_spacing: number;
                rowSpacing: number;
                selection_mode: SelectionMode;
                selectionMode: SelectionMode;
            }
        }

        /**
         * A `GtkFlowBox` puts child widgets in reflowing grid.
         *
         * For instance, with the horizontal orientation, the widgets will be
         * arranged from left to right, starting a new row under the previous
         * row when necessary. Reducing the width in this case will require more
         * rows, so a larger height will be requested.
         *
         * Likewise, with the vertical orientation, the widgets will be arranged
         * from top to bottom, starting a new column to the right when necessary.
         * Reducing the height will require more columns, so a larger width will
         * be requested.
         *
         * The size request of a `GtkFlowBox` alone may not be what you expect;
         * if you need to be able to shrink it along both axes and dynamically
         * reflow its children, you may have to wrap it in a `GtkScrolledWindow`
         * to enable that.
         *
         * The children of a `GtkFlowBox` can be dynamically sorted and filtered.
         *
         * Although a `GtkFlowBox` must have only `GtkFlowBoxChild` children, you
         * can add any kind of widget to it via [method`Gtk`.FlowBox.insert], and a
         * `GtkFlowBoxChild` widget will automatically be inserted between the box
         * and the widget.
         *
         * Also see [class`Gtk`.ListBox].
         *
         * # Shortcuts and Gestures
         *
         * The following signals have default keybindings:
         *
         * - [signal`Gtk`.FlowBox::move-cursor]
         * - [signal`Gtk`.FlowBox::select-all]
         * - [signal`Gtk`.FlowBox::toggle-cursor-child]
         * - [signal`Gtk`.FlowBox::unselect-all]
         *
         * # CSS nodes
         *
         * ```
         * flowbox
         * ├── flowboxchild
         * │   ╰── <child>
         * ├── flowboxchild
         * │   ╰── <child>
         * ┊
         * ╰── [rubberband]
         * ```
         *
         * `GtkFlowBox` uses a single CSS node with name flowbox. `GtkFlowBoxChild`
         * uses a single CSS node with name flowboxchild. For rubberband selection,
         * a subnode with name rubberband is used.
         *
         * # Accessibility
         *
         * `GtkFlowBox` uses the %GTK_ACCESSIBLE_ROLE_GRID role, and `GtkFlowBoxChild`
         * uses the %GTK_ACCESSIBLE_ROLE_GRID_CELL role.
         */
        class FlowBox extends Widget implements Accessible, Buildable, ConstraintTarget, Orientable {
            static $gtype: GObject.GType<FlowBox>;

            // Properties

            /**
             * Whether to accept unpaired release events.
             */
            get accept_unpaired_release(): boolean;
            set accept_unpaired_release(val: boolean);
            /**
             * Whether to accept unpaired release events.
             */
            get acceptUnpairedRelease(): boolean;
            set acceptUnpairedRelease(val: boolean);
            /**
             * Determines whether children can be activated with a single
             * click, or require a double-click.
             */
            get activate_on_single_click(): boolean;
            set activate_on_single_click(val: boolean);
            /**
             * Determines whether children can be activated with a single
             * click, or require a double-click.
             */
            get activateOnSingleClick(): boolean;
            set activateOnSingleClick(val: boolean);
            /**
             * The amount of horizontal space between two children.
             */
            get column_spacing(): number;
            set column_spacing(val: number);
            /**
             * The amount of horizontal space between two children.
             */
            get columnSpacing(): number;
            set columnSpacing(val: number);
            /**
             * Determines whether all children should be allocated the
             * same size.
             */
            get homogeneous(): boolean;
            set homogeneous(val: boolean);
            /**
             * The maximum amount of children to request space for consecutively
             * in the given orientation.
             */
            get max_children_per_line(): number;
            set max_children_per_line(val: number);
            /**
             * The maximum amount of children to request space for consecutively
             * in the given orientation.
             */
            get maxChildrenPerLine(): number;
            set maxChildrenPerLine(val: number);
            /**
             * The minimum number of children to allocate consecutively
             * in the given orientation.
             *
             * Setting the minimum children per line ensures
             * that a reasonably small height will be requested
             * for the overall minimum width of the box.
             */
            get min_children_per_line(): number;
            set min_children_per_line(val: number);
            /**
             * The minimum number of children to allocate consecutively
             * in the given orientation.
             *
             * Setting the minimum children per line ensures
             * that a reasonably small height will be requested
             * for the overall minimum width of the box.
             */
            get minChildrenPerLine(): number;
            set minChildrenPerLine(val: number);
            /**
             * The amount of vertical space between two children.
             */
            get row_spacing(): number;
            set row_spacing(val: number);
            /**
             * The amount of vertical space between two children.
             */
            get rowSpacing(): number;
            set rowSpacing(val: number);
            /**
             * The selection mode used by the flow box.
             */
            get selection_mode(): SelectionMode;
            set selection_mode(val: SelectionMode);
            /**
             * The selection mode used by the flow box.
             */
            get selectionMode(): SelectionMode;
            set selectionMode(val: SelectionMode);

            // Constructors

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

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

            static ['new'](): FlowBox;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate-cursor-child', callback: (_source: this) => void): number;
            connect_after(signal: 'activate-cursor-child', callback: (_source: this) => void): number;
            emit(signal: 'activate-cursor-child'): void;
            connect(signal: 'child-activated', callback: (_source: this, child: FlowBoxChild) => void): number;
            connect_after(signal: 'child-activated', callback: (_source: this, child: FlowBoxChild) => void): number;
            emit(signal: 'child-activated', child: FlowBoxChild): void;
            connect(
                signal: 'move-cursor',
                callback: (
                    _source: this,
                    step: MovementStep,
                    count: number,
                    extend: boolean,
                    modify: boolean,
                ) => boolean,
            ): number;
            connect_after(
                signal: 'move-cursor',
                callback: (
                    _source: this,
                    step: MovementStep,
                    count: number,
                    extend: boolean,
                    modify: boolean,
                ) => boolean,
            ): number;
            emit(signal: 'move-cursor', step: MovementStep, count: number, extend: boolean, modify: boolean): void;
            connect(signal: 'select-all', callback: (_source: this) => void): number;
            connect_after(signal: 'select-all', callback: (_source: this) => void): number;
            emit(signal: 'select-all'): void;
            connect(signal: 'selected-children-changed', callback: (_source: this) => void): number;
            connect_after(signal: 'selected-children-changed', callback: (_source: this) => void): number;
            emit(signal: 'selected-children-changed'): void;
            connect(signal: 'toggle-cursor-child', callback: (_source: this) => void): number;
            connect_after(signal: 'toggle-cursor-child', callback: (_source: this) => void): number;
            emit(signal: 'toggle-cursor-child'): void;
            connect(signal: 'unselect-all', callback: (_source: this) => void): number;
            connect_after(signal: 'unselect-all', callback: (_source: this) => void): number;
            emit(signal: 'unselect-all'): void;

            // Methods

            /**
             * Adds `child` to the end of `self`.
             *
             * If a sort function is set, the widget will
             * actually be inserted at the calculated position.
             *
             * See also: [method`Gtk`.FlowBox.insert].
             * @param child the `GtkWidget` to add
             */
            append(child: Widget): void;
            /**
             * Binds `model` to `box`.
             *
             * If `box` was already bound to a model, that previous binding is
             * destroyed.
             *
             * The contents of `box` are cleared and then filled with widgets that
             * represent items from `model`. `box` is updated whenever `model` changes.
             * If `model` is %NULL, `box` is left empty.
             *
             * It is undefined to add or remove widgets directly (for example, with
             * [method`Gtk`.FlowBox.insert]) while `box` is bound to a model.
             *
             * Note that using a model is incompatible with the filtering and sorting
             * functionality in `GtkFlowBox`. When using a model, filtering and sorting
             * should be implemented by the model.
             * @param model the `GListModel` to be bound to @box
             * @param create_widget_func a function   that creates widgets for items
             */
            bind_model<A extends GObject.Object = GObject.Object>(
                model: Gio.ListModel<A>,
                create_widget_func: FlowBoxCreateWidgetFunc<A>,
            ): void;
            /**
             * Returns whether children activate on single clicks.
             * @returns %TRUE if children are activated on single click,   %FALSE otherwise
             */
            get_activate_on_single_click(): boolean;
            /**
             * Gets the nth child in the `box`.
             * @param idx the position of the child
             * @returns the child widget, which will   always be a `GtkFlowBoxChild` or %NULL in case no child widget   with the given index exists.
             */
            get_child_at_index(idx: number): FlowBoxChild | null;
            /**
             * Gets the child in the (`x,` `y)` position.
             *
             * Both `x` and `y` are assumed to be relative to the origin of `box`.
             * @param x the x coordinate of the child
             * @param y the y coordinate of the child
             * @returns the child widget, which will   always be a `GtkFlowBoxChild` or %NULL in case no child widget   exists for the given x and y coordinates.
             */
            get_child_at_pos(x: number, y: number): FlowBoxChild | null;
            /**
             * Gets the horizontal spacing.
             * @returns the horizontal spacing
             */
            get_column_spacing(): number;
            /**
             * Returns whether the box is homogeneous.
             * @returns %TRUE if the box is homogeneous.
             */
            get_homogeneous(): boolean;
            /**
             * Gets the maximum number of children per line.
             * @returns the maximum number of children per line
             */
            get_max_children_per_line(): number;
            /**
             * Gets the minimum number of children per line.
             * @returns the minimum number of children per line
             */
            get_min_children_per_line(): number;
            /**
             * Gets the vertical spacing.
             * @returns the vertical spacing
             */
            get_row_spacing(): number;
            /**
             * Creates a list of all selected children.
             * @returns A `GList` containing the `GtkWidget` for each selected child.   Free with g_list_free() when done.
             */
            get_selected_children(): FlowBoxChild[];
            /**
             * Gets the selection mode of `box`.
             * @returns the `GtkSelectionMode`
             */
            get_selection_mode(): SelectionMode;
            /**
             * Inserts the `widget` into `box` at `position`.
             *
             * If a sort function is set, the widget will actually be inserted
             * at the calculated position.
             *
             * If `position` is -1, or larger than the total number of children
             * in the `box,` then the `widget` will be appended to the end.
             * @param widget the `GtkWidget` to add
             * @param position the position to insert @child in
             */
            insert(widget: Widget, position: number): void;
            /**
             * Updates the filtering for all children.
             *
             * Call this function when the result of the filter
             * function on the `box` is changed due to an external
             * factor. For instance, this would be used if the
             * filter function just looked for a specific search
             * term, and the entry with the string has changed.
             */
            invalidate_filter(): void;
            /**
             * Updates the sorting for all children.
             *
             * Call this when the result of the sort function on
             * `box` is changed due to an external factor.
             */
            invalidate_sort(): void;
            /**
             * Adds `child` to the start of `self`.
             *
             * If a sort function is set, the widget will
             * actually be inserted at the calculated position.
             *
             * See also: [method`Gtk`.FlowBox.insert].
             * @param child the `GtkWidget` to add
             */
            prepend(child: Widget): void;
            /**
             * Removes a child from `box`.
             * @param widget the child widget to remove
             */
            remove(widget: Widget): void;
            /**
             * Removes all children from `box`.
             *
             * This function does nothing if `box` is backed by a model.
             */
            remove_all(): void;
            /**
             * Select all children of `box,` if the selection
             * mode allows it.
             */
            select_all(): void;
            /**
             * Selects a single child of `box,` if the selection
             * mode allows it.
             * @param child a child of @box
             */
            select_child(child: FlowBoxChild): void;
            /**
             * Calls a function for each selected child.
             *
             * Note that the selection cannot be modified from within
             * this function.
             * @param func the function to call for each selected child
             */
            selected_foreach(func: FlowBoxForeachFunc): void;
            /**
             * If `single` is %TRUE, children will be activated when you click
             * on them, otherwise you need to double-click.
             * @param single %TRUE to emit child-activated on a single click
             */
            set_activate_on_single_click(single: boolean): void;
            /**
             * Sets the horizontal space to add between children.
             * @param spacing the spacing to use
             */
            set_column_spacing(spacing: number): void;
            /**
             * By setting a filter function on the `box` one can decide dynamically
             * which of the children to show.
             *
             * For instance, to implement a search function that only shows the
             * children matching the search terms.
             *
             * The `filter_func` will be called for each child after the call, and
             * it will continue to be called each time a child changes (via
             * [method`Gtk`.FlowBoxChild.changed]) or when
             * [method`Gtk`.FlowBox.invalidate_filter] is called.
             *
             * Note that using a filter function is incompatible with using a model
             * (see [method`Gtk`.FlowBox.bind_model]).
             * @param filter_func callback   that lets you filter which children to show
             */
            set_filter_func(filter_func?: FlowBoxFilterFunc | null): void;
            /**
             * Hooks up an adjustment to focus handling in `box`.
             *
             * The adjustment is also used for autoscrolling during
             * rubberband selection. See [method`Gtk`.ScrolledWindow.get_hadjustment]
             * for a typical way of obtaining the adjustment, and
             * [method`Gtk`.FlowBox.set_vadjustment] for setting the vertical
             * adjustment.
             *
             * The adjustments have to be in pixel units and in the same
             * coordinate system as the allocation for immediate children
             * of the box.
             * @param adjustment an adjustment which should be adjusted    when the focus is moved among the descendents of @container
             */
            set_hadjustment(adjustment: Adjustment): void;
            /**
             * Sets whether or not all children of `box` are given
             * equal space in the box.
             * @param homogeneous %TRUE to create equal allotments,   %FALSE for variable allotments
             */
            set_homogeneous(homogeneous: boolean): void;
            /**
             * Sets the maximum number of children to request and
             * allocate space for in `box’`s orientation.
             *
             * Setting the maximum number of children per line
             * limits the overall natural size request to be no more
             * than `n_children` children long in the given orientation.
             * @param n_children the maximum number of children per line
             */
            set_max_children_per_line(n_children: number): void;
            /**
             * Sets the minimum number of children to line up
             * in `box’`s orientation before flowing.
             * @param n_children the minimum number of children per line
             */
            set_min_children_per_line(n_children: number): void;
            /**
             * Sets the vertical space to add between children.
             * @param spacing the spacing to use
             */
            set_row_spacing(spacing: number): void;
            /**
             * Sets how selection works in `box`.
             * @param mode the new selection mode
             */
            set_selection_mode(mode: SelectionMode | null): void;
            /**
             * By setting a sort function on the `box,` one can dynamically
             * reorder the children of the box, based on the contents of
             * the children.
             *
             * The `sort_func` will be called for each child after the call,
             * and will continue to be called each time a child changes (via
             * [method`Gtk`.FlowBoxChild.changed]) and when
             * [method`Gtk`.FlowBox.invalidate_sort] is called.
             *
             * Note that using a sort function is incompatible with using a model
             * (see [method`Gtk`.FlowBox.bind_model]).
             * @param sort_func the sort function
             */
            set_sort_func(sort_func?: FlowBoxSortFunc | null): void;
            /**
             * Hooks up an adjustment to focus handling in `box`.
             *
             * The adjustment is also used for autoscrolling during
             * rubberband selection. See [method`Gtk`.ScrolledWindow.get_vadjustment]
             * for a typical way of obtaining the adjustment, and
             * [method`Gtk`.FlowBox.set_hadjustment] for setting the horizontal
             * adjustment.
             *
             * The adjustments have to be in pixel units and in the same
             * coordinate system as the allocation for immediate children
             * of the box.
             * @param adjustment an adjustment which should be adjusted    when the focus is moved among the descendents of @container
             */
            set_vadjustment(adjustment: Adjustment): void;
            /**
             * Unselect all children of `box,` if the selection
             * mode allows it.
             */
            unselect_all(): void;
            /**
             * Unselects a single child of `box,` if the selection
             * mode allows it.
             * @param child a child of @box
             */
            unselect_child(child: FlowBoxChild): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace FlowBoxChild {
            // Signal callback interfaces

            interface Activate {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                child: Widget;
            }
        }

        /**
         * `GtkFlowBoxChild` is the kind of widget that can be added to a `GtkFlowBox`.
         */
        class FlowBoxChild extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<FlowBoxChild>;

            // Properties

            /**
             * The child widget.
             */
            get child(): Widget;
            set child(val: Widget);

            // Constructors

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

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

            static ['new'](): FlowBoxChild;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate', callback: (_source: this) => void): number;
            connect_after(signal: 'activate', callback: (_source: this) => void): number;
            emit(signal: 'activate'): void;

            // Virtual methods

            vfunc_activate(): void;

            // Methods

            /**
             * Marks `child` as changed, causing any state that depends on this
             * to be updated.
             *
             * This affects sorting and filtering.
             *
             * Note that calls to this method must be in sync with the data
             * used for the sorting and filtering functions. For instance, if
             * the list is mirroring some external data set, and *two* children
             * changed in the external data set when you call
             * gtk_flow_box_child_changed() on the first child, the sort function
             * must only read the new data for the first of the two changed
             * children, otherwise the resorting of the children will be wrong.
             *
             * This generally means that if you don’t fully control the data
             * model, you have to duplicate the data that affects the sorting
             * and filtering functions into the widgets themselves.
             *
             * Another alternative is to call [method`Gtk`.FlowBox.invalidate_sort]
             * on any model change, but that is more expensive.
             */
            changed(): void;
            /**
             * Gets the child widget of `self`.
             * @returns the child widget of @self
             */
            get_child(): Widget | null;
            /**
             * Gets the current index of the `child` in its `GtkFlowBox` container.
             * @returns the index of the @child, or -1 if the @child is not   in a flow box
             */
            get_index(): number;
            /**
             * Returns whether the `child` is currently selected in its
             * `GtkFlowBox` container.
             * @returns %TRUE if @child is selected
             */
            is_selected(): boolean;
            /**
             * Sets the child widget of `self`.
             * @param child the child widget
             */
            set_child(child?: Widget | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace FontButton {
            // Signal callback interfaces

            interface Activate {
                (): void;
            }

            interface FontSet {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    FontChooser.ConstructorProps {
                modal: boolean;
                title: string;
                use_font: boolean;
                useFont: boolean;
                use_size: boolean;
                useSize: boolean;
            }
        }

        /**
         * The `GtkFontButton` allows to open a font chooser dialog to change
         * the font.
         *
         * ![An example GtkFontButton](font-button.png)
         *
         * It is suitable widget for selecting a font in a preference dialog.
         *
         * # CSS nodes
         *
         * ```
         * fontbutton
         * ╰── button.font
         *     ╰── [content]
         * ```
         *
         * `GtkFontButton` has a single CSS node with name fontbutton which
         * contains a button node with the .font style class.
         */
        class FontButton extends Widget implements Accessible, Buildable, ConstraintTarget, FontChooser {
            static $gtype: GObject.GType<FontButton>;

            // Properties

            /**
             * Whether the font chooser dialog should be modal.
             */
            get modal(): boolean;
            set modal(val: boolean);
            /**
             * The title of the font chooser dialog.
             */
            get title(): string;
            set title(val: string);
            /**
             * Whether the buttons label will be drawn in the selected font.
             */
            get use_font(): boolean;
            set use_font(val: boolean);
            /**
             * Whether the buttons label will be drawn in the selected font.
             */
            get useFont(): boolean;
            set useFont(val: boolean);
            /**
             * Whether the buttons label will use the selected font size.
             */
            get use_size(): boolean;
            set use_size(val: boolean);
            /**
             * Whether the buttons label will use the selected font size.
             */
            get useSize(): boolean;
            set useSize(val: boolean);

            // Constructors

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

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

            static ['new'](): FontButton;

            static new_with_font(fontname: string): FontButton;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate', callback: (_source: this) => void): number;
            connect_after(signal: 'activate', callback: (_source: this) => void): number;
            emit(signal: 'activate'): void;
            connect(signal: 'font-set', callback: (_source: this) => void): number;
            connect_after(signal: 'font-set', callback: (_source: this) => void): number;
            emit(signal: 'font-set'): void;

            // Methods

            /**
             * Gets whether the dialog is modal.
             * @returns %TRUE if the dialog is modal
             */
            get_modal(): boolean;
            /**
             * Retrieves the title of the font chooser dialog.
             * @returns an internal copy of the title string   which must not be freed.
             */
            get_title(): string;
            /**
             * Returns whether the selected font is used in the label.
             * @returns whether the selected font is used in the label.
             */
            get_use_font(): boolean;
            /**
             * Returns whether the selected size is used in the label.
             * @returns whether the selected size is used in the label.
             */
            get_use_size(): boolean;
            /**
             * Sets whether the dialog should be modal.
             * @param modal %TRUE to make the dialog modal
             */
            set_modal(modal: boolean): void;
            /**
             * Sets the title for the font chooser dialog.
             * @param title a string containing the font chooser dialog title
             */
            set_title(title: string): void;
            /**
             * If `use_font` is %TRUE, the font name will be written
             * using the selected font.
             * @param use_font If %TRUE, font name will be written using font chosen.
             */
            set_use_font(use_font: boolean): void;
            /**
             * If `use_size` is %TRUE, the font name will be written using
             * the selected size.
             * @param use_size If %TRUE, font name will be written using the   selected size.
             */
            set_use_size(use_size: boolean): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The font description as a string, e.g. "Sans Italic 12".
             */
            get font(): string;
            set font(val: string);
            /**
             * The font description as a `PangoFontDescription`.
             */
            get font_desc(): Pango.FontDescription;
            set font_desc(val: Pango.FontDescription);
            /**
             * The font description as a `PangoFontDescription`.
             */
            get fontDesc(): Pango.FontDescription;
            set fontDesc(val: Pango.FontDescription);
            /**
             * The selected font features.
             *
             * The format of the string is compatible with
             * CSS and with Pango attributes.
             */
            get font_features(): string;
            /**
             * The selected font features.
             *
             * The format of the string is compatible with
             * CSS and with Pango attributes.
             */
            get fontFeatures(): string;
            /**
             * The language for which the font features were selected.
             */
            get language(): string;
            set language(val: string);
            /**
             * The level of granularity to offer for selecting fonts.
             */
            get level(): FontChooserLevel;
            set level(val: FontChooserLevel);
            /**
             * The string with which to preview the font.
             */
            get preview_text(): string;
            set preview_text(val: string);
            /**
             * The string with which to preview the font.
             */
            get previewText(): string;
            set previewText(val: string);
            /**
             * Whether to show an entry to change the preview text.
             */
            get show_preview_entry(): boolean;
            set show_preview_entry(val: boolean);
            /**
             * Whether to show an entry to change the preview text.
             */
            get showPreviewEntry(): boolean;
            set showPreviewEntry(val: boolean);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Gets the currently-selected font name.
             *
             * Note that this can be a different string than what you set with
             * [method`Gtk`.FontChooser.set_font], as the font chooser widget may
             * normalize font names and thus return a string with a different
             * structure. For example, “Helvetica Italic Bold 12” could be
             * normalized to “Helvetica Bold Italic 12”.
             *
             * Use [method`Pango`.FontDescription.equal] if you want to compare two
             * font descriptions.
             * @returns A string with the name   of the current font
             */
            get_font(): string | null;
            /**
             * Gets the currently-selected font.
             *
             * Note that this can be a different string than what you set with
             * [method`Gtk`.FontChooser.set_font], as the font chooser widget may
             * normalize font names and thus return a string with a different
             * structure. For example, “Helvetica Italic Bold 12” could be
             * normalized to “Helvetica Bold Italic 12”.
             *
             * Use [method`Pango`.FontDescription.equal] if you want to compare two
             * font descriptions.
             * @returns A `PangoFontDescription` for the   current font
             */
            get_font_desc(): Pango.FontDescription | null;
            /**
             * Gets the `PangoFontFace` representing the selected font group
             * details (i.e. family, slant, weight, width, etc).
             *
             * If the selected font is not installed, returns %NULL.
             * @returns A `PangoFontFace` representing the   selected font group details
             */
            get_font_face(): Pango.FontFace | null;
            /**
             * Gets the `PangoFontFamily` representing the selected font family.
             *
             * Font families are a collection of font faces.
             *
             * If the selected font is not installed, returns %NULL.
             * @returns A `PangoFontFamily` representing the   selected font family
             */
            get_font_family(): Pango.FontFamily | null;
            /**
             * Gets the currently-selected font features.
             *
             * The format of the returned string is compatible with the
             * [CSS font-feature-settings property](https://www.w3.org/TR/css-fonts-4/#font-rend-desc).
             * It can be passed to [func`Pango`.AttrFontFeatures.new].
             * @returns the currently selected font features
             */
            get_font_features(): string;
            /**
             * Gets the custom font map of this font chooser widget,
             * or %NULL if it does not have one.
             * @returns a `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * The selected font size.
             * @returns A n integer representing the selected font size,   or -1 if no font size is selected.
             */
            get_font_size(): number;
            /**
             * Gets the language that is used for font features.
             * @returns the currently selected language
             */
            get_language(): string;
            /**
             * Returns the current level of granularity for selecting fonts.
             * @returns the current granularity level
             */
            get_level(): FontChooserLevel;
            /**
             * Gets the text displayed in the preview area.
             * @returns the text displayed in the preview area
             */
            get_preview_text(): string;
            /**
             * Returns whether the preview entry is shown or not.
             * @returns %TRUE if the preview entry is shown or %FALSE if it is hidden.
             */
            get_show_preview_entry(): boolean;
            /**
             * Adds a filter function that decides which fonts to display
             * in the font chooser.
             * @param filter a `GtkFontFilterFunc`
             */
            set_filter_func(filter?: FontFilterFunc | null): void;
            /**
             * Sets the currently-selected font.
             * @param fontname a font name like “Helvetica 12” or “Times Bold 18”
             */
            set_font(fontname: string): void;
            /**
             * Sets the currently-selected font from `font_desc`.
             * @param font_desc a `PangoFontDescription`
             */
            set_font_desc(font_desc: Pango.FontDescription): void;
            /**
             * Sets a custom font map to use for this font chooser widget.
             *
             * A custom font map can be used to present application-specific
             * fonts instead of or in addition to the normal system fonts.
             *
             * ```c
             * FcConfig *config;
             * PangoFontMap *fontmap;
             *
             * config = FcInitLoadConfigAndFonts ();
             * FcConfigAppFontAddFile (config, my_app_font_file);
             *
             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
             *
             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
             * ```
             *
             * Note that other GTK widgets will only be able to use the
             * application-specific font if it is present in the font map they use:
             *
             * ```c
             * context = gtk_widget_get_pango_context (label);
             * pango_context_set_font_map (context, fontmap);
             * ```
             * @param fontmap a `PangoFontMap`
             */
            set_font_map(fontmap?: Pango.FontMap | null): void;
            /**
             * Sets the language to use for font features.
             * @param language a language
             */
            set_language(language: string): void;
            /**
             * Sets the desired level of granularity for selecting fonts.
             * @param level the desired level of granularity
             */
            set_level(level: FontChooserLevel | null): void;
            /**
             * Sets the text displayed in the preview area.
             *
             * The `text` is used to show how the selected font looks.
             * @param text the text to display in the preview area
             */
            set_preview_text(text: string): void;
            /**
             * Shows or hides the editable preview entry.
             * @param show_preview_entry whether to show the editable preview entry or not
             */
            set_show_preview_entry(show_preview_entry: boolean): void;
            vfunc_font_activated(fontname: string): void;
            /**
             * Gets the `PangoFontFace` representing the selected font group
             * details (i.e. family, slant, weight, width, etc).
             *
             * If the selected font is not installed, returns %NULL.
             */
            vfunc_get_font_face(): Pango.FontFace | null;
            /**
             * Gets the `PangoFontFamily` representing the selected font family.
             *
             * Font families are a collection of font faces.
             *
             * If the selected font is not installed, returns %NULL.
             */
            vfunc_get_font_family(): Pango.FontFamily | null;
            /**
             * Gets the custom font map of this font chooser widget,
             * or %NULL if it does not have one.
             */
            vfunc_get_font_map(): Pango.FontMap | null;
            /**
             * The selected font size.
             */
            vfunc_get_font_size(): number;
            /**
             * Adds a filter function that decides which fonts to display
             * in the font chooser.
             * @param filter a `GtkFontFilterFunc`
             */
            vfunc_set_filter_func(filter?: FontFilterFunc | null): void;
            /**
             * Sets a custom font map to use for this font chooser widget.
             *
             * A custom font map can be used to present application-specific
             * fonts instead of or in addition to the normal system fonts.
             *
             * ```c
             * FcConfig *config;
             * PangoFontMap *fontmap;
             *
             * config = FcInitLoadConfigAndFonts ();
             * FcConfigAppFontAddFile (config, my_app_font_file);
             *
             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
             *
             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
             * ```
             *
             * Note that other GTK widgets will only be able to use the
             * application-specific font if it is present in the font map they use:
             *
             * ```c
             * context = gtk_widget_get_pango_context (label);
             * pango_context_set_font_map (context, fontmap);
             * ```
             * @param fontmap a `PangoFontMap`
             */
            vfunc_set_font_map(fontmap?: Pango.FontMap | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace FontChooserDialog {
            // Constructor properties interface

            interface ConstructorProps
                extends Dialog.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    FontChooser.ConstructorProps,
                    Native.ConstructorProps,
                    Root.ConstructorProps,
                    ShortcutManager.ConstructorProps {}
        }

        /**
         * The `GtkFontChooserDialog` widget is a dialog for selecting a font.
         *
         * ![An example GtkFontChooserDialog](fontchooser.png)
         *
         * `GtkFontChooserDialog` implements the [iface`Gtk`.FontChooser] interface
         * and does not provide much API of its own.
         *
         * To create a `GtkFontChooserDialog`, use [ctor`Gtk`.FontChooserDialog.new].
         *
         * # GtkFontChooserDialog as GtkBuildable
         *
         * The `GtkFontChooserDialog` implementation of the `GtkBuildable`
         * interface exposes the buttons with the names “select_button”
         * and “cancel_button”.
         *
         * ## CSS nodes
         *
         * `GtkFontChooserDialog` has a single CSS node with the name `window` and style
         * class `.fontchooser`.
         */
        class FontChooserDialog
            extends Dialog
            implements Accessible, Buildable, ConstraintTarget, FontChooser, Native, Root, ShortcutManager
        {
            static $gtype: GObject.GType<FontChooserDialog>;

            // Constructors

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

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

            static ['new'](title?: string | null, parent?: Window | null): FontChooserDialog;
            // Conflicted with Gtk.Dialog.new

            static ['new'](...args: never[]): any;

            // Inherited properties
            /**
             * The font description as a string, e.g. "Sans Italic 12".
             */
            get font(): string;
            set font(val: string);
            /**
             * The font description as a `PangoFontDescription`.
             */
            get font_desc(): Pango.FontDescription;
            set font_desc(val: Pango.FontDescription);
            /**
             * The font description as a `PangoFontDescription`.
             */
            get fontDesc(): Pango.FontDescription;
            set fontDesc(val: Pango.FontDescription);
            /**
             * The selected font features.
             *
             * The format of the string is compatible with
             * CSS and with Pango attributes.
             */
            get font_features(): string;
            /**
             * The selected font features.
             *
             * The format of the string is compatible with
             * CSS and with Pango attributes.
             */
            get fontFeatures(): string;
            /**
             * The language for which the font features were selected.
             */
            get language(): string;
            set language(val: string);
            /**
             * The level of granularity to offer for selecting fonts.
             */
            get level(): FontChooserLevel;
            set level(val: FontChooserLevel);
            /**
             * The string with which to preview the font.
             */
            get preview_text(): string;
            set preview_text(val: string);
            /**
             * The string with which to preview the font.
             */
            get previewText(): string;
            set previewText(val: string);
            /**
             * Whether to show an entry to change the preview text.
             */
            get show_preview_entry(): boolean;
            set show_preview_entry(val: boolean);
            /**
             * Whether to show an entry to change the preview text.
             */
            get showPreviewEntry(): boolean;
            set showPreviewEntry(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Gets the currently-selected font name.
             *
             * Note that this can be a different string than what you set with
             * [method`Gtk`.FontChooser.set_font], as the font chooser widget may
             * normalize font names and thus return a string with a different
             * structure. For example, “Helvetica Italic Bold 12” could be
             * normalized to “Helvetica Bold Italic 12”.
             *
             * Use [method`Pango`.FontDescription.equal] if you want to compare two
             * font descriptions.
             * @returns A string with the name   of the current font
             */
            get_font(): string | null;
            /**
             * Gets the currently-selected font.
             *
             * Note that this can be a different string than what you set with
             * [method`Gtk`.FontChooser.set_font], as the font chooser widget may
             * normalize font names and thus return a string with a different
             * structure. For example, “Helvetica Italic Bold 12” could be
             * normalized to “Helvetica Bold Italic 12”.
             *
             * Use [method`Pango`.FontDescription.equal] if you want to compare two
             * font descriptions.
             * @returns A `PangoFontDescription` for the   current font
             */
            get_font_desc(): Pango.FontDescription | null;
            /**
             * Gets the `PangoFontFace` representing the selected font group
             * details (i.e. family, slant, weight, width, etc).
             *
             * If the selected font is not installed, returns %NULL.
             * @returns A `PangoFontFace` representing the   selected font group details
             */
            get_font_face(): Pango.FontFace | null;
            /**
             * Gets the `PangoFontFamily` representing the selected font family.
             *
             * Font families are a collection of font faces.
             *
             * If the selected font is not installed, returns %NULL.
             * @returns A `PangoFontFamily` representing the   selected font family
             */
            get_font_family(): Pango.FontFamily | null;
            /**
             * Gets the currently-selected font features.
             *
             * The format of the returned string is compatible with the
             * [CSS font-feature-settings property](https://www.w3.org/TR/css-fonts-4/#font-rend-desc).
             * It can be passed to [func`Pango`.AttrFontFeatures.new].
             * @returns the currently selected font features
             */
            get_font_features(): string;
            /**
             * Gets the custom font map of this font chooser widget,
             * or %NULL if it does not have one.
             * @returns a `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * The selected font size.
             * @returns A n integer representing the selected font size,   or -1 if no font size is selected.
             */
            get_font_size(): number;
            /**
             * Gets the language that is used for font features.
             * @returns the currently selected language
             */
            get_language(): string;
            /**
             * Returns the current level of granularity for selecting fonts.
             * @returns the current granularity level
             */
            get_level(): FontChooserLevel;
            /**
             * Gets the text displayed in the preview area.
             * @returns the text displayed in the preview area
             */
            get_preview_text(): string;
            /**
             * Returns whether the preview entry is shown or not.
             * @returns %TRUE if the preview entry is shown or %FALSE if it is hidden.
             */
            get_show_preview_entry(): boolean;
            /**
             * Adds a filter function that decides which fonts to display
             * in the font chooser.
             * @param filter a `GtkFontFilterFunc`
             */
            set_filter_func(filter?: FontFilterFunc | null): void;
            /**
             * Sets the currently-selected font.
             * @param fontname a font name like “Helvetica 12” or “Times Bold 18”
             */
            set_font(fontname: string): void;
            /**
             * Sets the currently-selected font from `font_desc`.
             * @param font_desc a `PangoFontDescription`
             */
            set_font_desc(font_desc: Pango.FontDescription): void;
            /**
             * Sets a custom font map to use for this font chooser widget.
             *
             * A custom font map can be used to present application-specific
             * fonts instead of or in addition to the normal system fonts.
             *
             * ```c
             * FcConfig *config;
             * PangoFontMap *fontmap;
             *
             * config = FcInitLoadConfigAndFonts ();
             * FcConfigAppFontAddFile (config, my_app_font_file);
             *
             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
             *
             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
             * ```
             *
             * Note that other GTK widgets will only be able to use the
             * application-specific font if it is present in the font map they use:
             *
             * ```c
             * context = gtk_widget_get_pango_context (label);
             * pango_context_set_font_map (context, fontmap);
             * ```
             * @param fontmap a `PangoFontMap`
             */
            set_font_map(fontmap?: Pango.FontMap | null): void;
            /**
             * Sets the language to use for font features.
             * @param language a language
             */
            set_language(language: string): void;
            /**
             * Sets the desired level of granularity for selecting fonts.
             * @param level the desired level of granularity
             */
            set_level(level: FontChooserLevel | null): void;
            /**
             * Sets the text displayed in the preview area.
             *
             * The `text` is used to show how the selected font looks.
             * @param text the text to display in the preview area
             */
            set_preview_text(text: string): void;
            /**
             * Shows or hides the editable preview entry.
             * @param show_preview_entry whether to show the editable preview entry or not
             */
            set_show_preview_entry(show_preview_entry: boolean): void;
            vfunc_font_activated(fontname: string): void;
            /**
             * Gets the `PangoFontFace` representing the selected font group
             * details (i.e. family, slant, weight, width, etc).
             *
             * If the selected font is not installed, returns %NULL.
             */
            vfunc_get_font_face(): Pango.FontFace | null;
            /**
             * Gets the `PangoFontFamily` representing the selected font family.
             *
             * Font families are a collection of font faces.
             *
             * If the selected font is not installed, returns %NULL.
             */
            vfunc_get_font_family(): Pango.FontFamily | null;
            /**
             * Gets the custom font map of this font chooser widget,
             * or %NULL if it does not have one.
             */
            vfunc_get_font_map(): Pango.FontMap | null;
            /**
             * The selected font size.
             */
            vfunc_get_font_size(): number;
            /**
             * Adds a filter function that decides which fonts to display
             * in the font chooser.
             * @param filter a `GtkFontFilterFunc`
             */
            vfunc_set_filter_func(filter?: FontFilterFunc | null): void;
            /**
             * Sets a custom font map to use for this font chooser widget.
             *
             * A custom font map can be used to present application-specific
             * fonts instead of or in addition to the normal system fonts.
             *
             * ```c
             * FcConfig *config;
             * PangoFontMap *fontmap;
             *
             * config = FcInitLoadConfigAndFonts ();
             * FcConfigAppFontAddFile (config, my_app_font_file);
             *
             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
             *
             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
             * ```
             *
             * Note that other GTK widgets will only be able to use the
             * application-specific font if it is present in the font map they use:
             *
             * ```c
             * context = gtk_widget_get_pango_context (label);
             * pango_context_set_font_map (context, fontmap);
             * ```
             * @param fontmap a `PangoFontMap`
             */
            vfunc_set_font_map(fontmap?: Pango.FontMap | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace FontChooserWidget {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    FontChooser.ConstructorProps {
                tweak_action: Gio.Action;
                tweakAction: Gio.Action;
            }
        }

        /**
         * The `GtkFontChooserWidget` widget lets the user select a font.
         *
         * It is used in the `GtkFontChooserDialog` widget to provide a
         * dialog for selecting fonts.
         *
         * To set the font which is initially selected, use
         * [method`Gtk`.FontChooser.set_font] or [method`Gtk`.FontChooser.set_font_desc].
         *
         * To get the selected font use [method`Gtk`.FontChooser.get_font] or
         * [method`Gtk`.FontChooser.get_font_desc].
         *
         * To change the text which is shown in the preview area, use
         * [method`Gtk`.FontChooser.set_preview_text].
         *
         * # CSS nodes
         *
         * `GtkFontChooserWidget` has a single CSS node with name fontchooser.
         */
        class FontChooserWidget extends Widget implements Accessible, Buildable, ConstraintTarget, FontChooser {
            static $gtype: GObject.GType<FontChooserWidget>;

            // Properties

            /**
             * A toggle action that can be used to switch to the tweak page
             * of the font chooser widget, which lets the user tweak the
             * OpenType features and variation axes of the selected font.
             *
             * The action will be enabled or disabled depending on whether
             * the selected font has any features or axes.
             */
            get tweak_action(): Gio.Action;
            /**
             * A toggle action that can be used to switch to the tweak page
             * of the font chooser widget, which lets the user tweak the
             * OpenType features and variation axes of the selected font.
             *
             * The action will be enabled or disabled depending on whether
             * the selected font has any features or axes.
             */
            get tweakAction(): Gio.Action;

            // Constructors

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

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

            static ['new'](): FontChooserWidget;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The font description as a string, e.g. "Sans Italic 12".
             */
            get font(): string;
            set font(val: string);
            /**
             * The font description as a `PangoFontDescription`.
             */
            get font_desc(): Pango.FontDescription;
            set font_desc(val: Pango.FontDescription);
            /**
             * The font description as a `PangoFontDescription`.
             */
            get fontDesc(): Pango.FontDescription;
            set fontDesc(val: Pango.FontDescription);
            /**
             * The selected font features.
             *
             * The format of the string is compatible with
             * CSS and with Pango attributes.
             */
            get font_features(): string;
            /**
             * The selected font features.
             *
             * The format of the string is compatible with
             * CSS and with Pango attributes.
             */
            get fontFeatures(): string;
            /**
             * The language for which the font features were selected.
             */
            get language(): string;
            set language(val: string);
            /**
             * The level of granularity to offer for selecting fonts.
             */
            get level(): FontChooserLevel;
            set level(val: FontChooserLevel);
            /**
             * The string with which to preview the font.
             */
            get preview_text(): string;
            set preview_text(val: string);
            /**
             * The string with which to preview the font.
             */
            get previewText(): string;
            set previewText(val: string);
            /**
             * Whether to show an entry to change the preview text.
             */
            get show_preview_entry(): boolean;
            set show_preview_entry(val: boolean);
            /**
             * Whether to show an entry to change the preview text.
             */
            get showPreviewEntry(): boolean;
            set showPreviewEntry(val: boolean);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Gets the currently-selected font name.
             *
             * Note that this can be a different string than what you set with
             * [method`Gtk`.FontChooser.set_font], as the font chooser widget may
             * normalize font names and thus return a string with a different
             * structure. For example, “Helvetica Italic Bold 12” could be
             * normalized to “Helvetica Bold Italic 12”.
             *
             * Use [method`Pango`.FontDescription.equal] if you want to compare two
             * font descriptions.
             * @returns A string with the name   of the current font
             */
            get_font(): string | null;
            /**
             * Gets the currently-selected font.
             *
             * Note that this can be a different string than what you set with
             * [method`Gtk`.FontChooser.set_font], as the font chooser widget may
             * normalize font names and thus return a string with a different
             * structure. For example, “Helvetica Italic Bold 12” could be
             * normalized to “Helvetica Bold Italic 12”.
             *
             * Use [method`Pango`.FontDescription.equal] if you want to compare two
             * font descriptions.
             * @returns A `PangoFontDescription` for the   current font
             */
            get_font_desc(): Pango.FontDescription | null;
            /**
             * Gets the `PangoFontFace` representing the selected font group
             * details (i.e. family, slant, weight, width, etc).
             *
             * If the selected font is not installed, returns %NULL.
             * @returns A `PangoFontFace` representing the   selected font group details
             */
            get_font_face(): Pango.FontFace | null;
            /**
             * Gets the `PangoFontFamily` representing the selected font family.
             *
             * Font families are a collection of font faces.
             *
             * If the selected font is not installed, returns %NULL.
             * @returns A `PangoFontFamily` representing the   selected font family
             */
            get_font_family(): Pango.FontFamily | null;
            /**
             * Gets the currently-selected font features.
             *
             * The format of the returned string is compatible with the
             * [CSS font-feature-settings property](https://www.w3.org/TR/css-fonts-4/#font-rend-desc).
             * It can be passed to [func`Pango`.AttrFontFeatures.new].
             * @returns the currently selected font features
             */
            get_font_features(): string;
            /**
             * Gets the custom font map of this font chooser widget,
             * or %NULL if it does not have one.
             * @returns a `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * The selected font size.
             * @returns A n integer representing the selected font size,   or -1 if no font size is selected.
             */
            get_font_size(): number;
            /**
             * Gets the language that is used for font features.
             * @returns the currently selected language
             */
            get_language(): string;
            /**
             * Returns the current level of granularity for selecting fonts.
             * @returns the current granularity level
             */
            get_level(): FontChooserLevel;
            /**
             * Gets the text displayed in the preview area.
             * @returns the text displayed in the preview area
             */
            get_preview_text(): string;
            /**
             * Returns whether the preview entry is shown or not.
             * @returns %TRUE if the preview entry is shown or %FALSE if it is hidden.
             */
            get_show_preview_entry(): boolean;
            /**
             * Adds a filter function that decides which fonts to display
             * in the font chooser.
             * @param filter a `GtkFontFilterFunc`
             */
            set_filter_func(filter?: FontFilterFunc | null): void;
            /**
             * Sets the currently-selected font.
             * @param fontname a font name like “Helvetica 12” or “Times Bold 18”
             */
            set_font(fontname: string): void;
            /**
             * Sets the currently-selected font from `font_desc`.
             * @param font_desc a `PangoFontDescription`
             */
            set_font_desc(font_desc: Pango.FontDescription): void;
            /**
             * Sets a custom font map to use for this font chooser widget.
             *
             * A custom font map can be used to present application-specific
             * fonts instead of or in addition to the normal system fonts.
             *
             * ```c
             * FcConfig *config;
             * PangoFontMap *fontmap;
             *
             * config = FcInitLoadConfigAndFonts ();
             * FcConfigAppFontAddFile (config, my_app_font_file);
             *
             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
             *
             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
             * ```
             *
             * Note that other GTK widgets will only be able to use the
             * application-specific font if it is present in the font map they use:
             *
             * ```c
             * context = gtk_widget_get_pango_context (label);
             * pango_context_set_font_map (context, fontmap);
             * ```
             * @param fontmap a `PangoFontMap`
             */
            set_font_map(fontmap?: Pango.FontMap | null): void;
            /**
             * Sets the language to use for font features.
             * @param language a language
             */
            set_language(language: string): void;
            /**
             * Sets the desired level of granularity for selecting fonts.
             * @param level the desired level of granularity
             */
            set_level(level: FontChooserLevel | null): void;
            /**
             * Sets the text displayed in the preview area.
             *
             * The `text` is used to show how the selected font looks.
             * @param text the text to display in the preview area
             */
            set_preview_text(text: string): void;
            /**
             * Shows or hides the editable preview entry.
             * @param show_preview_entry whether to show the editable preview entry or not
             */
            set_show_preview_entry(show_preview_entry: boolean): void;
            vfunc_font_activated(fontname: string): void;
            /**
             * Gets the `PangoFontFace` representing the selected font group
             * details (i.e. family, slant, weight, width, etc).
             *
             * If the selected font is not installed, returns %NULL.
             */
            vfunc_get_font_face(): Pango.FontFace | null;
            /**
             * Gets the `PangoFontFamily` representing the selected font family.
             *
             * Font families are a collection of font faces.
             *
             * If the selected font is not installed, returns %NULL.
             */
            vfunc_get_font_family(): Pango.FontFamily | null;
            /**
             * Gets the custom font map of this font chooser widget,
             * or %NULL if it does not have one.
             */
            vfunc_get_font_map(): Pango.FontMap | null;
            /**
             * The selected font size.
             */
            vfunc_get_font_size(): number;
            /**
             * Adds a filter function that decides which fonts to display
             * in the font chooser.
             * @param filter a `GtkFontFilterFunc`
             */
            vfunc_set_filter_func(filter?: FontFilterFunc | null): void;
            /**
             * Sets a custom font map to use for this font chooser widget.
             *
             * A custom font map can be used to present application-specific
             * fonts instead of or in addition to the normal system fonts.
             *
             * ```c
             * FcConfig *config;
             * PangoFontMap *fontmap;
             *
             * config = FcInitLoadConfigAndFonts ();
             * FcConfigAppFontAddFile (config, my_app_font_file);
             *
             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
             *
             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
             * ```
             *
             * Note that other GTK widgets will only be able to use the
             * application-specific font if it is present in the font map they use:
             *
             * ```c
             * context = gtk_widget_get_pango_context (label);
             * pango_context_set_font_map (context, fontmap);
             * ```
             * @param fontmap a `PangoFontMap`
             */
            vfunc_set_font_map(fontmap?: Pango.FontMap | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace FontDialog {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                filter: Filter;
                font_map: Pango.FontMap;
                fontMap: Pango.FontMap;
                language: Pango.Language;
                modal: boolean;
                title: string;
            }
        }

        /**
         * A `GtkFontDialog` object collects the arguments that
         * are needed to present a font chooser dialog to the
         * user, such as a title for the dialog and whether it
         * should be modal.
         *
         * The dialog is shown with the [method`Gtk`.FontDialog.choose_font]
         * function or its variants.
         *
         * See [class`Gtk`.FontDialogButton] for a convenient control
         * that uses `GtkFontDialog` and presents the results.
         */
        class FontDialog extends GObject.Object {
            static $gtype: GObject.GType<FontDialog>;

            // Properties

            /**
             * Sets a filter to restrict what fonts are shown
             * in the font chooser dialog.
             */
            get filter(): Filter;
            set filter(val: Filter);
            /**
             * Sets a custom font map to select fonts from.
             *
             * A custom font map can be used to present application-specific
             * fonts instead of or in addition to the normal system fonts.
             */
            get font_map(): Pango.FontMap;
            set font_map(val: Pango.FontMap);
            /**
             * Sets a custom font map to select fonts from.
             *
             * A custom font map can be used to present application-specific
             * fonts instead of or in addition to the normal system fonts.
             */
            get fontMap(): Pango.FontMap;
            set fontMap(val: Pango.FontMap);
            /**
             * The language for which the font features are selected.
             */
            get language(): Pango.Language;
            set language(val: Pango.Language);
            /**
             * Whether the font chooser dialog is modal.
             */
            get modal(): boolean;
            set modal(val: boolean);
            /**
             * A title that may be shown on the font chooser
             * dialog that is presented by [method`Gtk`.FontDialog.choose_font].
             */
            get title(): string;
            set title(val: string);

            // Constructors

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

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

            static ['new'](): FontDialog;

            // Methods

            /**
             * This function initiates a font selection operation by
             * presenting a dialog to the user for selecting a font face
             * (i.e. a font family and style, but not a specific font size).
             * @param parent the parent `GtkWindow`
             * @param initial_value the initial value
             * @param cancellable a `GCancellable` to cancel the operation
             */
            choose_face(
                parent?: Window | null,
                initial_value?: Pango.FontFace | null,
                cancellable?: Gio.Cancellable | null,
            ): Promise<Pango.FontFace | null>;
            /**
             * This function initiates a font selection operation by
             * presenting a dialog to the user for selecting a font face
             * (i.e. a font family and style, but not a specific font size).
             * @param parent the parent `GtkWindow`
             * @param initial_value the initial value
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            choose_face(
                parent: Window | null,
                initial_value: Pango.FontFace | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * This function initiates a font selection operation by
             * presenting a dialog to the user for selecting a font face
             * (i.e. a font family and style, but not a specific font size).
             * @param parent the parent `GtkWindow`
             * @param initial_value the initial value
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            choose_face(
                parent?: Window | null,
                initial_value?: Pango.FontFace | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<Pango.FontFace | null> | void;
            /**
             * Finishes the [method`Gtk`.FontDialog.choose_face] call
             * and returns the resulting font face.
             * @param result a `GAsyncResult`
             * @returns the selected font face
             */
            choose_face_finish(result: Gio.AsyncResult): Pango.FontFace | null;
            /**
             * This function initiates a font selection operation by
             * presenting a dialog to the user for selecting a font family.
             * @param parent the parent `GtkWindow`
             * @param initial_value the initial value
             * @param cancellable a `GCancellable` to cancel the operation
             */
            choose_family(
                parent?: Window | null,
                initial_value?: Pango.FontFamily | null,
                cancellable?: Gio.Cancellable | null,
            ): Promise<Pango.FontFamily | null>;
            /**
             * This function initiates a font selection operation by
             * presenting a dialog to the user for selecting a font family.
             * @param parent the parent `GtkWindow`
             * @param initial_value the initial value
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            choose_family(
                parent: Window | null,
                initial_value: Pango.FontFamily | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * This function initiates a font selection operation by
             * presenting a dialog to the user for selecting a font family.
             * @param parent the parent `GtkWindow`
             * @param initial_value the initial value
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            choose_family(
                parent?: Window | null,
                initial_value?: Pango.FontFamily | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<Pango.FontFamily | null> | void;
            /**
             * Finishes the [method`Gtk`.FontDialog.choose_family] call
             * and returns the resulting family.
             *
             * This function never returns an error. If the operation is
             * not finished successfully, the value passed as `initial_value`
             * to [method`Gtk`.FontDialog.choose_family] is returned.
             * @param result a `GAsyncResult`
             * @returns the selected family
             */
            choose_family_finish(result: Gio.AsyncResult): Pango.FontFamily | null;
            /**
             * This function initiates a font selection operation by
             * presenting a dialog to the user for selecting a font.
             *
             * If you want to let the user select font features as well,
             * use [method`Gtk`.FontDialog.choose_font_and_features] instead.
             * @param parent the parent `GtkWindow`
             * @param initial_value the font to select initially
             * @param cancellable a `GCancellable` to cancel the operation
             */
            choose_font(
                parent?: Window | null,
                initial_value?: Pango.FontDescription | null,
                cancellable?: Gio.Cancellable | null,
            ): Promise<Pango.FontDescription | null>;
            /**
             * This function initiates a font selection operation by
             * presenting a dialog to the user for selecting a font.
             *
             * If you want to let the user select font features as well,
             * use [method`Gtk`.FontDialog.choose_font_and_features] instead.
             * @param parent the parent `GtkWindow`
             * @param initial_value the font to select initially
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            choose_font(
                parent: Window | null,
                initial_value: Pango.FontDescription | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * This function initiates a font selection operation by
             * presenting a dialog to the user for selecting a font.
             *
             * If you want to let the user select font features as well,
             * use [method`Gtk`.FontDialog.choose_font_and_features] instead.
             * @param parent the parent `GtkWindow`
             * @param initial_value the font to select initially
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            choose_font(
                parent?: Window | null,
                initial_value?: Pango.FontDescription | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<Pango.FontDescription | null> | void;
            /**
             * This function initiates a font selection operation by
             * presenting a dialog to the user for selecting a font and
             * font features.
             *
             * Font features affect how the font is rendered, for example
             * enabling glyph variants or ligatures.
             * @param parent the parent `GtkWindow`
             * @param initial_value the font to select initially
             * @param cancellable a `GCancellable` to cancel the operation
             */
            choose_font_and_features(
                parent?: Window | null,
                initial_value?: Pango.FontDescription | null,
                cancellable?: Gio.Cancellable | null,
            ): Promise<[Pango.FontDescription, string, Pango.Language]>;
            /**
             * This function initiates a font selection operation by
             * presenting a dialog to the user for selecting a font and
             * font features.
             *
             * Font features affect how the font is rendered, for example
             * enabling glyph variants or ligatures.
             * @param parent the parent `GtkWindow`
             * @param initial_value the font to select initially
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            choose_font_and_features(
                parent: Window | null,
                initial_value: Pango.FontDescription | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * This function initiates a font selection operation by
             * presenting a dialog to the user for selecting a font and
             * font features.
             *
             * Font features affect how the font is rendered, for example
             * enabling glyph variants or ligatures.
             * @param parent the parent `GtkWindow`
             * @param initial_value the font to select initially
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            choose_font_and_features(
                parent?: Window | null,
                initial_value?: Pango.FontDescription | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<[Pango.FontDescription, string, Pango.Language]> | void;
            /**
             * Finishes the [method`Gtk`.FontDialog.choose_font_and_features]
             * call and returns the resulting font description and font features.
             * @param result a `GAsyncResult`
             * @returns `TRUE` if a font was selected. Otherwise `FALSE` is returned   and @error is set
             */
            choose_font_and_features_finish(
                result: Gio.AsyncResult,
            ): [boolean, Pango.FontDescription, string, Pango.Language];
            /**
             * Finishes the [method`Gtk`.FontDialog.choose_font] call
             * and returns the resulting font description.
             * @param result a `GAsyncResult`
             * @returns the selected font
             */
            choose_font_finish(result: Gio.AsyncResult): Pango.FontDescription | null;
            /**
             * Returns the filter that decides which fonts to display
             * in the font chooser dialog.
             * @returns the filter
             */
            get_filter(): Filter | null;
            /**
             * Returns the fontmap from which fonts are selected,
             * or `NULL` for the default fontmap.
             * @returns the fontmap
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the language for which font features are applied.
             * @returns the language for font features
             */
            get_language(): Pango.Language | null;
            /**
             * Returns whether the font chooser dialog
             * blocks interaction with the parent window
             * while it is presented.
             * @returns `TRUE` if the font chooser dialog is modal
             */
            get_modal(): boolean;
            /**
             * Returns the title that will be shown on the
             * font chooser dialog.
             * @returns the title
             */
            get_title(): string;
            /**
             * Adds a filter that decides which fonts to display
             * in the font chooser dialog.
             *
             * The `GtkFilter` must be able to handle both `PangoFontFamily`
             * and `PangoFontFace` objects.
             * @param filter a `GtkFilter`
             */
            set_filter(filter?: Filter | null): void;
            /**
             * Sets the fontmap from which fonts are selected.
             *
             * If `fontmap` is `NULL`, the default fontmap is used.
             * @param fontmap the fontmap
             */
            set_font_map(fontmap?: Pango.FontMap | null): void;
            /**
             * Sets the language for which font features are applied.
             * @param language the language for font features
             */
            set_language(language: Pango.Language): void;
            /**
             * Sets whether the font chooser dialog
             * blocks interaction with the parent window
             * while it is presented.
             * @param modal the new value
             */
            set_modal(modal: boolean): void;
            /**
             * Sets the title that will be shown on the
             * font chooser dialog.
             * @param title the new title
             */
            set_title(title: string): void;
        }

        namespace FontDialogButton {
            // Signal callback interfaces

            interface Activate {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                dialog: FontDialog;
                font_desc: Pango.FontDescription;
                fontDesc: Pango.FontDescription;
                font_features: string;
                fontFeatures: string;
                language: Pango.Language;
                level: FontLevel;
                use_font: boolean;
                useFont: boolean;
                use_size: boolean;
                useSize: boolean;
            }
        }

        /**
         * The `GtkFontDialogButton` is wrapped around a [class`Gtk`.FontDialog]
         * and allows to open a font chooser dialog to change the font.
         *
         * ![An example GtkFontDialogButton](font-button.png)
         *
         * It is suitable widget for selecting a font in a preference dialog.
         *
         * # CSS nodes
         *
         * ```
         * fontbutton
         * ╰── button.font
         *     ╰── [content]
         * ```
         *
         * `GtkFontDialogButton` has a single CSS node with name fontbutton which
         * contains a button node with the .font style class.
         */
        class FontDialogButton extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<FontDialogButton>;

            // Properties

            /**
             * The `GtkFontDialog` that contains parameters for
             * the font chooser dialog.
             */
            get dialog(): FontDialog;
            set dialog(val: FontDialog);
            /**
             * The selected font.
             *
             * This property can be set to give the button its initial
             * font, and it will be updated to reflect the users choice
             * in the font chooser dialog.
             *
             * Listen to `notify::font-desc` to get informed about changes
             * to the buttons font.
             */
            get font_desc(): Pango.FontDescription;
            set font_desc(val: Pango.FontDescription);
            /**
             * The selected font.
             *
             * This property can be set to give the button its initial
             * font, and it will be updated to reflect the users choice
             * in the font chooser dialog.
             *
             * Listen to `notify::font-desc` to get informed about changes
             * to the buttons font.
             */
            get fontDesc(): Pango.FontDescription;
            set fontDesc(val: Pango.FontDescription);
            /**
             * The selected font features.
             *
             * This property will be updated to reflect the users choice
             * in the font chooser dialog.
             *
             * Listen to `notify::font-features` to get informed about changes
             * to the buttons font features.
             */
            get font_features(): string;
            set font_features(val: string);
            /**
             * The selected font features.
             *
             * This property will be updated to reflect the users choice
             * in the font chooser dialog.
             *
             * Listen to `notify::font-features` to get informed about changes
             * to the buttons font features.
             */
            get fontFeatures(): string;
            set fontFeatures(val: string);
            /**
             * The selected language for font features.
             *
             * This property will be updated to reflect the users choice
             * in the font chooser dialog.
             *
             * Listen to `notify::language` to get informed about changes
             * to the buttons language.
             */
            get language(): Pango.Language;
            set language(val: Pango.Language);
            /**
             * The level of detail for the font chooser dialog.
             */
            get level(): FontLevel;
            set level(val: FontLevel);
            /**
             * Whether the buttons label will be drawn in the selected font.
             */
            get use_font(): boolean;
            set use_font(val: boolean);
            /**
             * Whether the buttons label will be drawn in the selected font.
             */
            get useFont(): boolean;
            set useFont(val: boolean);
            /**
             * Whether the buttons label will use the selected font size.
             */
            get use_size(): boolean;
            set use_size(val: boolean);
            /**
             * Whether the buttons label will use the selected font size.
             */
            get useSize(): boolean;
            set useSize(val: boolean);

            // Constructors

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

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

            static ['new'](dialog?: FontDialog | null): FontDialogButton;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate', callback: (_source: this) => void): number;
            connect_after(signal: 'activate', callback: (_source: this) => void): number;
            emit(signal: 'activate'): void;

            // Methods

            /**
             * Returns the `GtkFontDialog` of `self`.
             * @returns the `GtkFontDialog`
             */
            get_dialog(): FontDialog | null;
            /**
             * Returns the font of the button.
             *
             * This function is what should be used to obtain
             * the font that was chosen by the user. To get
             * informed about changes, listen to "notify::font-desc".
             * @returns the font
             */
            get_font_desc(): Pango.FontDescription | null;
            /**
             * Returns the font features of the button.
             *
             * This function is what should be used to obtain the font features
             * that were chosen by the user. To get informed about changes, listen
             * to "notify::font-features".
             *
             * Note that the button will only let users choose font features
             * if [property`Gtk`.FontDialogButton:level] is set to
             * `GTK_FONT_LEVEL_FEATURES`.
             * @returns the font features
             */
            get_font_features(): string | null;
            /**
             * Returns the language that is used for font features.
             * @returns the language
             */
            get_language(): Pango.Language | null;
            /**
             * Returns the level of detail at which this dialog
             * lets the user select fonts.
             * @returns the level of detail
             */
            get_level(): FontLevel;
            /**
             * Returns whether the selected font is used in the label.
             * @returns whether the selected font is used in the label
             */
            get_use_font(): boolean;
            /**
             * Returns whether the selected font size is used in the label.
             * @returns whether the selected font size is used in the label
             */
            get_use_size(): boolean;
            /**
             * Sets a `GtkFontDialog` object to use for
             * creating the font chooser dialog that is
             * presented when the user clicks the button.
             * @param dialog the new `GtkFontDialog`
             */
            set_dialog(dialog: FontDialog): void;
            /**
             * Sets the font of the button.
             * @param font_desc the new font
             */
            set_font_desc(font_desc: Pango.FontDescription): void;
            /**
             * Sets the font features of the button.
             * @param font_features the font features
             */
            set_font_features(font_features?: string | null): void;
            /**
             * Sets the language to use for font features.
             * @param language the new language
             */
            set_language(language?: Pango.Language | null): void;
            /**
             * Sets the level of detail at which this dialog
             * lets the user select fonts.
             * @param level the level of detail
             */
            set_level(level: FontLevel | null): void;
            /**
             * If `use_font` is `TRUE`, the font name will be written
             * using the selected font.
             * @param use_font If `TRUE`, font name will be written using   the chosen font
             */
            set_use_font(use_font: boolean): void;
            /**
             * If `use_size` is `TRUE`, the font name will be written
             * using the selected font size.
             * @param use_size If `TRUE`, font name will be written using   the chosen font size
             */
            set_use_size(use_size: boolean): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Frame {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                child: Widget;
                label: string;
                label_widget: Widget;
                labelWidget: Widget;
                label_xalign: number;
                labelXalign: number;
            }
        }

        /**
         * `GtkFrame` is a widget that surrounds its child with a decorative
         * frame and an optional label.
         *
         * ![An example GtkFrame](frame.png)
         *
         * If present, the label is drawn inside the top edge of the frame.
         * The horizontal position of the label can be controlled with
         * [method`Gtk`.Frame.set_label_align].
         *
         * `GtkFrame` clips its child. You can use this to add rounded corners
         * to widgets, but be aware that it also cuts off shadows.
         *
         * # GtkFrame as GtkBuildable
         *
         * The `GtkFrame` implementation of the `GtkBuildable` interface supports
         * placing a child in the label position by specifying “label” as the
         * “type” attribute of a `<child>` element. A normal content child can
         * be specified without specifying a `<child>` type attribute.
         *
         * An example of a UI definition fragment with GtkFrame:
         * ```xml
         * <object class="GtkFrame">
         *   <child type="label">
         *     <object class="GtkLabel" id="frame_label"/>
         *   </child>
         *   <child>
         *     <object class="GtkEntry" id="frame_content"/>
         *   </child>
         * </object>
         * ```
         *
         * # CSS nodes
         *
         * ```
         * frame
         * ├── <label widget>
         * ╰── <child>
         * ```
         *
         * `GtkFrame` has a main CSS node with name “frame”, which is used to draw the
         * visible border. You can set the appearance of the border using CSS properties
         * like “border-style” on this node.
         *
         * # Accessibility
         *
         * `GtkFrame` uses the `GTK_ACCESSIBLE_ROLE_GROUP` role.
         */
        class Frame extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<Frame>;

            // Properties

            /**
             * The child widget.
             */
            get child(): Widget;
            set child(val: Widget);
            /**
             * Text of the frame's label.
             */
            get label(): string;
            set label(val: string);
            /**
             * Widget to display in place of the usual frame label.
             */
            get label_widget(): Widget;
            set label_widget(val: Widget);
            /**
             * Widget to display in place of the usual frame label.
             */
            get labelWidget(): Widget;
            set labelWidget(val: Widget);
            /**
             * The horizontal alignment of the label.
             */
            get label_xalign(): number;
            set label_xalign(val: number);
            /**
             * The horizontal alignment of the label.
             */
            get labelXalign(): number;
            set labelXalign(val: number);

            // Constructors

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

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

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

            // Virtual methods

            vfunc_compute_child_allocation(allocation: Allocation): void;

            // Methods

            /**
             * Gets the child widget of `frame`.
             * @returns the child widget of @frame
             */
            get_child(): Widget | null;
            /**
             * Returns the frame labels text.
             *
             * If the frame's label widget is not a `GtkLabel`, %NULL
             * is returned.
             * @returns the text in the label, or %NULL if there    was no label widget or the label widget was not a `GtkLabel`.    This string is owned by GTK and must not be modified or freed.
             */
            get_label(): string | null;
            /**
             * Retrieves the X alignment of the frame’s label.
             * @returns the frames X alignment
             */
            get_label_align(): number;
            /**
             * Retrieves the label widget for the frame.
             * @returns the label widget
             */
            get_label_widget(): Widget | null;
            /**
             * Sets the child widget of `frame`.
             * @param child the child widget
             */
            set_child(child?: Widget | null): void;
            /**
             * Creates a new `GtkLabel` with the `label` and sets it as the frame's
             * label widget.
             * @param label the text to use as the label of the frame
             */
            set_label(label?: string | null): void;
            /**
             * Sets the X alignment of the frame widget’s label.
             *
             * The default value for a newly created frame is 0.0.
             * @param xalign The position of the label along the top edge   of the widget. A value of 0.0 represents left alignment;   1.0 represents right alignment.
             */
            set_label_align(xalign: number): void;
            /**
             * Sets the label widget for the frame.
             *
             * This is the widget that will appear embedded in the top edge
             * of the frame as a title.
             * @param label_widget the new label widget
             */
            set_label_widget(label_widget?: Widget | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GLArea {
            // Signal callback interfaces

            interface CreateContext {
                (): Gdk.GLContext;
            }

            interface Render {
                (context: Gdk.GLContext): boolean;
            }

            interface Resize {
                (width: number, height: number): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                allowed_apis: Gdk.GLAPI;
                allowedApis: Gdk.GLAPI;
                api: Gdk.GLAPI;
                auto_render: boolean;
                autoRender: boolean;
                context: Gdk.GLContext;
                has_depth_buffer: boolean;
                hasDepthBuffer: boolean;
                has_stencil_buffer: boolean;
                hasStencilBuffer: boolean;
                use_es: boolean;
                useEs: boolean;
            }
        }

        /**
         * `GtkGLArea` is a widget that allows drawing with OpenGL.
         *
         * ![An example GtkGLArea](glarea.png)
         *
         * `GtkGLArea` sets up its own [class`Gdk`.GLContext], and creates a custom
         * GL framebuffer that the widget will do GL rendering onto. It also ensures
         * that this framebuffer is the default GL rendering target when rendering.
         * The completed rendering is integrated into the larger GTK scene graph as
         * a texture.
         *
         * In order to draw, you have to connect to the [signal`Gtk`.GLArea::render]
         * signal, or subclass `GtkGLArea` and override the GtkGLAreaClass.render
         * virtual function.
         *
         * The `GtkGLArea` widget ensures that the `GdkGLContext` is associated with
         * the widget's drawing area, and it is kept updated when the size and
         * position of the drawing area changes.
         *
         * ## Drawing with GtkGLArea
         *
         * The simplest way to draw using OpenGL commands in a `GtkGLArea` is to
         * create a widget instance and connect to the [signal`Gtk`.GLArea::render] signal:
         *
         * The `render()` function will be called when the `GtkGLArea` is ready
         * for you to draw its content:
         *
         * The initial contents of the framebuffer are transparent.
         *
         * ```c
         * static gboolean
         * render (GtkGLArea *area, GdkGLContext *context)
         * {
         *   // inside this function it's safe to use GL; the given
         *   // GdkGLContext has been made current to the drawable
         *   // surface used by the `GtkGLArea` and the viewport has
         *   // already been set to be the size of the allocation
         *
         *   // we can start by clearing the buffer
         *   glClearColor (0, 0, 0, 0);
         *   glClear (GL_COLOR_BUFFER_BIT);
         *
         *   // draw your object
         *   // draw_an_object ();
         *
         *   // we completed our drawing; the draw commands will be
         *   // flushed at the end of the signal emission chain, and
         *   // the buffers will be drawn on the window
         *   return TRUE;
         * }
         *
         * void setup_glarea (void)
         * {
         *   // create a GtkGLArea instance
         *   GtkWidget *gl_area = gtk_gl_area_new ();
         *
         *   // connect to the "render" signal
         *   g_signal_connect (gl_area, "render", G_CALLBACK (render), NULL);
         * }
         * ```
         *
         * If you need to initialize OpenGL state, e.g. buffer objects or
         * shaders, you should use the [signal`Gtk`.Widget::realize] signal;
         * you can use the [signal`Gtk`.Widget::unrealize] signal to clean up.
         * Since the `GdkGLContext` creation and initialization may fail, you
         * will need to check for errors, using [method`Gtk`.GLArea.get_error].
         *
         * An example of how to safely initialize the GL state is:
         *
         * ```c
         * static void
         * on_realize (GtkGLarea *area)
         * {
         *   // We need to make the context current if we want to
         *   // call GL API
         *   gtk_gl_area_make_current (area);
         *
         *   // If there were errors during the initialization or
         *   // when trying to make the context current, this
         *   // function will return a GError for you to catch
         *   if (gtk_gl_area_get_error (area) != NULL)
         *     return;
         *
         *   // You can also use gtk_gl_area_set_error() in order
         *   // to show eventual initialization errors on the
         *   // GtkGLArea widget itself
         *   GError *internal_error = NULL;
         *   init_buffer_objects (&error);
         *   if (error != NULL)
         *     {
         *       gtk_gl_area_set_error (area, error);
         *       g_error_free (error);
         *       return;
         *     }
         *
         *   init_shaders (&error);
         *   if (error != NULL)
         *     {
         *       gtk_gl_area_set_error (area, error);
         *       g_error_free (error);
         *       return;
         *     }
         * }
         * ```
         *
         * If you need to change the options for creating the `GdkGLContext`
         * you should use the [signal`Gtk`.GLArea::create-context] signal.
         */
        class GLArea extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<GLArea>;

            // Properties

            /**
             * The allowed APIs.
             */
            get allowed_apis(): Gdk.GLAPI;
            set allowed_apis(val: Gdk.GLAPI);
            /**
             * The allowed APIs.
             */
            get allowedApis(): Gdk.GLAPI;
            set allowedApis(val: Gdk.GLAPI);
            /**
             * The API currently in use.
             */
            get api(): Gdk.GLAPI;
            /**
             * If set to %TRUE the ::render signal will be emitted every time
             * the widget draws.
             *
             * This is the default and is useful if drawing the widget is faster.
             *
             * If set to %FALSE the data from previous rendering is kept around and will
             * be used for drawing the widget the next time, unless the window is resized.
             * In order to force a rendering [method`Gtk`.GLArea.queue_render] must be called.
             * This mode is useful when the scene changes seldom, but takes a long time
             * to redraw.
             */
            get auto_render(): boolean;
            set auto_render(val: boolean);
            /**
             * If set to %TRUE the ::render signal will be emitted every time
             * the widget draws.
             *
             * This is the default and is useful if drawing the widget is faster.
             *
             * If set to %FALSE the data from previous rendering is kept around and will
             * be used for drawing the widget the next time, unless the window is resized.
             * In order to force a rendering [method`Gtk`.GLArea.queue_render] must be called.
             * This mode is useful when the scene changes seldom, but takes a long time
             * to redraw.
             */
            get autoRender(): boolean;
            set autoRender(val: boolean);
            /**
             * The `GdkGLContext` used by the `GtkGLArea` widget.
             *
             * The `GtkGLArea` widget is responsible for creating the `GdkGLContext`
             * instance. If you need to render with other kinds of buffers (stencil,
             * depth, etc), use render buffers.
             */
            get context(): Gdk.GLContext;
            /**
             * If set to %TRUE the widget will allocate and enable a depth buffer for the
             * target framebuffer.
             *
             * Setting this property will enable GL's depth testing as a side effect. If
             * you don't need depth testing, you should call `glDisable(GL_DEPTH_TEST)`
             * in your `GtkGLArea::render` handler.
             */
            get has_depth_buffer(): boolean;
            set has_depth_buffer(val: boolean);
            /**
             * If set to %TRUE the widget will allocate and enable a depth buffer for the
             * target framebuffer.
             *
             * Setting this property will enable GL's depth testing as a side effect. If
             * you don't need depth testing, you should call `glDisable(GL_DEPTH_TEST)`
             * in your `GtkGLArea::render` handler.
             */
            get hasDepthBuffer(): boolean;
            set hasDepthBuffer(val: boolean);
            /**
             * If set to %TRUE the widget will allocate and enable a stencil buffer for the
             * target framebuffer.
             */
            get has_stencil_buffer(): boolean;
            set has_stencil_buffer(val: boolean);
            /**
             * If set to %TRUE the widget will allocate and enable a stencil buffer for the
             * target framebuffer.
             */
            get hasStencilBuffer(): boolean;
            set hasStencilBuffer(val: boolean);
            /**
             * If set to %TRUE the widget will try to create a `GdkGLContext` using
             * OpenGL ES instead of OpenGL.
             */
            get use_es(): boolean;
            set use_es(val: boolean);
            /**
             * If set to %TRUE the widget will try to create a `GdkGLContext` using
             * OpenGL ES instead of OpenGL.
             */
            get useEs(): boolean;
            set useEs(val: boolean);

            // Constructors

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

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

            static ['new'](): GLArea;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'create-context', callback: (_source: this) => Gdk.GLContext): number;
            connect_after(signal: 'create-context', callback: (_source: this) => Gdk.GLContext): number;
            emit(signal: 'create-context'): void;
            connect(signal: 'render', callback: (_source: this, context: Gdk.GLContext) => boolean): number;
            connect_after(signal: 'render', callback: (_source: this, context: Gdk.GLContext) => boolean): number;
            emit(signal: 'render', context: Gdk.GLContext): void;
            connect(signal: 'resize', callback: (_source: this, width: number, height: number) => void): number;
            connect_after(signal: 'resize', callback: (_source: this, width: number, height: number) => void): number;
            emit(signal: 'resize', width: number, height: number): void;

            // Virtual methods

            /**
             * class closure for the `GtkGLArea::render` signal
             * @param context
             */
            vfunc_render(context: Gdk.GLContext): boolean;
            /**
             * class closeure for the `GtkGLArea::resize` signal
             * @param width
             * @param height
             */
            vfunc_resize(width: number, height: number): void;

            // Methods

            /**
             * Binds buffers to the framebuffer.
             *
             * Ensures that the `area` framebuffer object is made the current draw
             * and read target, and that all the required buffers for the `area`
             * are created and bound to the framebuffer.
             *
             * This function is automatically called before emitting the
             * [signal`Gtk`.GLArea::render] signal, and doesn't normally need to be
             * called by application code.
             */
            attach_buffers(): void;
            /**
             * Gets the allowed APIs.
             *
             * See [method`Gtk`.GLArea.set_allowed_apis].
             * @returns the allowed APIs
             */
            get_allowed_apis(): Gdk.GLAPI;
            /**
             * Gets the API that is currently in use.
             *
             * If the GL area has not been realized yet, 0 is returned.
             * @returns the currently used API
             */
            get_api(): Gdk.GLAPI;
            /**
             * Returns whether the area is in auto render mode or not.
             * @returns %TRUE if the @area is auto rendering, %FALSE otherwise
             */
            get_auto_render(): boolean;
            /**
             * Retrieves the `GdkGLContext` used by `area`.
             * @returns the `GdkGLContext`
             */
            get_context(): Gdk.GLContext | null;
            /**
             * Gets the current error set on the `area`.
             * @returns the `GError`
             */
            get_error(): GLib.Error | null;
            /**
             * Returns whether the area has a depth buffer.
             * @returns %TRUE if the @area has a depth buffer, %FALSE otherwise
             */
            get_has_depth_buffer(): boolean;
            /**
             * Returns whether the area has a stencil buffer.
             * @returns %TRUE if the @area has a stencil buffer, %FALSE otherwise
             */
            get_has_stencil_buffer(): boolean;
            /**
             * Retrieves the required version of OpenGL.
             *
             * See [method`Gtk`.GLArea.set_required_version].
             */
            get_required_version(): [number, number];
            /**
             * Returns whether the `GtkGLArea` should use OpenGL ES.
             *
             * See [method`Gtk`.GLArea.set_use_es].
             * @returns %TRUE if the `GtkGLArea` should create an OpenGL ES context   and %FALSE otherwise
             */
            get_use_es(): boolean;
            /**
             * Ensures that the `GdkGLContext` used by `area` is associated with
             * the `GtkGLArea`.
             *
             * This function is automatically called before emitting the
             * [signal`Gtk`.GLArea::render] signal, and doesn't normally need
             * to be called by application code.
             */
            make_current(): void;
            /**
             * Marks the currently rendered data (if any) as invalid, and queues
             * a redraw of the widget.
             *
             * This ensures that the [signal`Gtk`.GLArea::render] signal
             * is emitted during the draw.
             *
             * This is only needed when [method`Gtk`.GLArea.set_auto_render] has
             * been called with a %FALSE value. The default behaviour is to
             * emit [signal`Gtk`.GLArea::render] on each draw.
             */
            queue_render(): void;
            /**
             * Sets the allowed APIs to create a context with.
             *
             * You should check [property`Gtk`.GLArea:api] before drawing
             * with either API.
             *
             * By default, all APIs are allowed.
             * @param apis the allowed APIs
             */
            set_allowed_apis(apis: Gdk.GLAPI | null): void;
            /**
             * Sets whether the `GtkGLArea` is in auto render mode.
             *
             * If `auto_render` is %TRUE the [signal`Gtk`.GLArea::render] signal will
             * be emitted every time the widget draws. This is the default and is
             * useful if drawing the widget is faster.
             *
             * If `auto_render` is %FALSE the data from previous rendering is kept
             * around and will be used for drawing the widget the next time,
             * unless the window is resized. In order to force a rendering
             * [method`Gtk`.GLArea.queue_render] must be called. This mode is
             * useful when the scene changes seldom, but takes a long time to redraw.
             * @param auto_render a boolean
             */
            set_auto_render(auto_render: boolean): void;
            /**
             * Sets an error on the area which will be shown instead of the
             * GL rendering.
             *
             * This is useful in the [signal`Gtk`.GLArea::create-context]
             * signal if GL context creation fails.
             * @param error a new `GError`, or %NULL to unset the error
             */
            set_error(error?: GLib.Error | null): void;
            /**
             * Sets whether the `GtkGLArea` should use a depth buffer.
             *
             * If `has_depth_buffer` is %TRUE the widget will allocate and
             * enable a depth buffer for the target framebuffer. Otherwise
             * there will be none.
             * @param has_depth_buffer %TRUE to add a depth buffer
             */
            set_has_depth_buffer(has_depth_buffer: boolean): void;
            /**
             * Sets whether the `GtkGLArea` should use a stencil buffer.
             *
             * If `has_stencil_buffer` is %TRUE the widget will allocate and
             * enable a stencil buffer for the target framebuffer. Otherwise
             * there will be none.
             * @param has_stencil_buffer %TRUE to add a stencil buffer
             */
            set_has_stencil_buffer(has_stencil_buffer: boolean): void;
            /**
             * Sets the required version of OpenGL to be used when creating
             * the context for the widget.
             *
             * This function must be called before the area has been realized.
             * @param major the major version
             * @param minor the minor version
             */
            set_required_version(major: number, minor: number): void;
            /**
             * Sets whether the `area` should create an OpenGL or an OpenGL ES context.
             *
             * You should check the capabilities of the `GdkGLContext` before drawing
             * with either API.
             * @param use_es whether to use OpenGL or OpenGL ES
             */
            set_use_es(use_es: boolean): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Gesture {
            // Signal callback interfaces

            interface Begin {
                (sequence?: Gdk.EventSequence | null): void;
            }

            interface Cancel {
                (sequence?: Gdk.EventSequence | null): void;
            }

            interface End {
                (sequence?: Gdk.EventSequence | null): void;
            }

            interface SequenceStateChanged {
                (sequence: Gdk.EventSequence | null, state: EventSequenceState): void;
            }

            interface Update {
                (sequence?: Gdk.EventSequence | null): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends EventController.ConstructorProps {
                n_points: number;
                nPoints: number;
            }
        }

        /**
         * `GtkGesture` is the base class for gesture recognition.
         *
         * Although `GtkGesture` is quite generalized to serve as a base for
         * multi-touch gestures, it is suitable to implement single-touch and
         * pointer-based gestures (using the special %NULL `GdkEventSequence`
         * value for these).
         *
         * The number of touches that a `GtkGesture` need to be recognized is
         * controlled by the [property`Gtk`.Gesture:n-points] property, if a
         * gesture is keeping track of less or more than that number of sequences,
         * it won't check whether the gesture is recognized.
         *
         * As soon as the gesture has the expected number of touches, it will check
         * regularly if it is recognized, the criteria to consider a gesture as
         * "recognized" is left to `GtkGesture` subclasses.
         *
         * A recognized gesture will then emit the following signals:
         *
         * - [signal`Gtk`.Gesture::begin] when the gesture is recognized.
         * - [signal`Gtk`.Gesture::update], whenever an input event is processed.
         * - [signal`Gtk`.Gesture::end] when the gesture is no longer recognized.
         *
         * ## Event propagation
         *
         * In order to receive events, a gesture needs to set a propagation phase
         * through [method`Gtk`.EventController.set_propagation_phase].
         *
         * In the capture phase, events are propagated from the toplevel down
         * to the target widget, and gestures that are attached to containers
         * above the widget get a chance to interact with the event before it
         * reaches the target.
         *
         * In the bubble phase, events are propagated up from the target widget
         * to the toplevel, and gestures that are attached to containers above
         * the widget get a chance to interact with events that have not been
         * handled yet.
         *
         * ## States of a sequence
         *
         * Whenever input interaction happens, a single event may trigger a cascade
         * of `GtkGesture`s, both across the parents of the widget receiving the
         * event and in parallel within an individual widget. It is a responsibility
         * of the widgets using those gestures to set the state of touch sequences
         * accordingly in order to enable cooperation of gestures around the
         * `GdkEventSequence`s triggering those.
         *
         * Within a widget, gestures can be grouped through [method`Gtk`.Gesture.group].
         * Grouped gestures synchronize the state of sequences, so calling
         * [method`Gtk`.Gesture.set_state] on one will effectively propagate
         * the state throughout the group.
         *
         * By default, all sequences start out in the %GTK_EVENT_SEQUENCE_NONE state,
         * sequences in this state trigger the gesture event handler, but event
         * propagation will continue unstopped by gestures.
         *
         * If a sequence enters into the %GTK_EVENT_SEQUENCE_DENIED state, the gesture
         * group will effectively ignore the sequence, letting events go unstopped
         * through the gesture, but the "slot" will still remain occupied while
         * the touch is active.
         *
         * If a sequence enters in the %GTK_EVENT_SEQUENCE_CLAIMED state, the gesture
         * group will grab all interaction on the sequence, by:
         *
         * - Setting the same sequence to %GTK_EVENT_SEQUENCE_DENIED on every other
         *   gesture group within the widget, and every gesture on parent widgets
         *   in the propagation chain.
         * - Emitting [signal`Gtk`.Gesture::cancel] on every gesture in widgets
         *   underneath in the propagation chain.
         * - Stopping event propagation after the gesture group handles the event.
         *
         * Note: if a sequence is set early to %GTK_EVENT_SEQUENCE_CLAIMED on
         * %GDK_TOUCH_BEGIN/%GDK_BUTTON_PRESS (so those events are captured before
         * reaching the event widget, this implies %GTK_PHASE_CAPTURE), one similar
         * event will be emulated if the sequence changes to %GTK_EVENT_SEQUENCE_DENIED.
         * This way event coherence is preserved before event propagation is unstopped
         * again.
         *
         * Sequence states can't be changed freely.
         * See [method`Gtk`.Gesture.set_state] to know about the possible
         * lifetimes of a `GdkEventSequence`.
         *
         * ## Touchpad gestures
         *
         * On the platforms that support it, `GtkGesture` will handle transparently
         * touchpad gesture events. The only precautions users of `GtkGesture` should
         * do to enable this support are:
         *
         * - If the gesture has %GTK_PHASE_NONE, ensuring events of type
         *   %GDK_TOUCHPAD_SWIPE and %GDK_TOUCHPAD_PINCH are handled by the `GtkGesture`
         */
        abstract class Gesture extends EventController {
            static $gtype: GObject.GType<Gesture>;

            // Properties

            /**
             * The number of touch points that trigger
             * recognition on this gesture.
             */
            get n_points(): number;
            /**
             * The number of touch points that trigger
             * recognition on this gesture.
             */
            get nPoints(): number;

            // Constructors

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

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

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'begin', callback: (_source: this, sequence: Gdk.EventSequence | null) => void): number;
            connect_after(
                signal: 'begin',
                callback: (_source: this, sequence: Gdk.EventSequence | null) => void,
            ): number;
            emit(signal: 'begin', sequence?: Gdk.EventSequence | null): void;
            connect(signal: 'cancel', callback: (_source: this, sequence: Gdk.EventSequence | null) => void): number;
            connect_after(
                signal: 'cancel',
                callback: (_source: this, sequence: Gdk.EventSequence | null) => void,
            ): number;
            emit(signal: 'cancel', sequence?: Gdk.EventSequence | null): void;
            connect(signal: 'end', callback: (_source: this, sequence: Gdk.EventSequence | null) => void): number;
            connect_after(signal: 'end', callback: (_source: this, sequence: Gdk.EventSequence | null) => void): number;
            emit(signal: 'end', sequence?: Gdk.EventSequence | null): void;
            connect(
                signal: 'sequence-state-changed',
                callback: (_source: this, sequence: Gdk.EventSequence | null, state: EventSequenceState) => void,
            ): number;
            connect_after(
                signal: 'sequence-state-changed',
                callback: (_source: this, sequence: Gdk.EventSequence | null, state: EventSequenceState) => void,
            ): number;
            emit(signal: 'sequence-state-changed', sequence: Gdk.EventSequence | null, state: EventSequenceState): void;
            connect(signal: 'update', callback: (_source: this, sequence: Gdk.EventSequence | null) => void): number;
            connect_after(
                signal: 'update',
                callback: (_source: this, sequence: Gdk.EventSequence | null) => void,
            ): number;
            emit(signal: 'update', sequence?: Gdk.EventSequence | null): void;

            // Methods

            /**
             * If there are touch sequences being currently handled by `gesture,`
             * returns %TRUE and fills in `rect` with the bounding box containing
             * all active touches.
             *
             * Otherwise, %FALSE will be returned.
             *
             * Note: This function will yield unexpected results on touchpad
             * gestures. Since there is no correlation between physical and
             * pixel distances, these will look as if constrained in an
             * infinitely small area, `rect` width and height will thus be 0
             * regardless of the number of touchpoints.
             * @returns %TRUE if there are active touches, %FALSE otherwise
             */
            get_bounding_box(): [boolean, Gdk.Rectangle];
            /**
             * If there are touch sequences being currently handled by `gesture,`
             * returns %TRUE and fills in `x` and `y` with the center of the bounding
             * box containing all active touches.
             *
             * Otherwise, %FALSE will be returned.
             * @returns %FALSE if no active touches are present, %TRUE otherwise
             */
            get_bounding_box_center(): [boolean, number, number];
            /**
             * Returns the logical `GdkDevice` that is currently operating
             * on `gesture`.
             *
             * This returns %NULL if the gesture is not being interacted.
             * @returns a `GdkDevice`
             */
            get_device(): Gdk.Device | null;
            /**
             * Returns all gestures in the group of `gesture`
             * @returns The list   of `GtkGesture`s, free with g_list_free()
             */
            get_group(): Gesture[];
            /**
             * Returns the last event that was processed for `sequence`.
             *
             * Note that the returned pointer is only valid as long as the
             * `sequence` is still interpreted by the `gesture`. If in doubt,
             * you should make a copy of the event.
             * @param sequence a `GdkEventSequence`
             * @returns The last event from @sequence
             */
            get_last_event(sequence?: Gdk.EventSequence | null): Gdk.Event | null;
            /**
             * Returns the `GdkEventSequence` that was last updated on `gesture`.
             * @returns The last updated sequence
             */
            get_last_updated_sequence(): Gdk.EventSequence | null;
            /**
             * If `sequence` is currently being interpreted by `gesture,`
             * returns %TRUE and fills in `x` and `y` with the last coordinates
             * stored for that event sequence.
             *
             * The coordinates are always relative to the widget allocation.
             * @param sequence a `GdkEventSequence`, or %NULL for pointer events
             * @returns %TRUE if @sequence is currently interpreted
             */
            get_point(sequence: Gdk.EventSequence | null): [boolean, number, number];
            /**
             * Returns the `sequence` state, as seen by `gesture`.
             * @param sequence a `GdkEventSequence`
             * @returns The sequence state in @gesture
             */
            get_sequence_state(sequence: Gdk.EventSequence): EventSequenceState;
            /**
             * Returns the list of `GdkEventSequences` currently being interpreted
             * by `gesture`.
             * @returns A list   of `GdkEventSequence`, the list elements are owned by GTK and must   not be freed or modified, the list itself must be deleted   through g_list_free()
             */
            get_sequences(): Gdk.EventSequence[];
            /**
             * Adds `gesture` to the same group than `group_gesture`.
             *
             * Gestures are by default isolated in their own groups.
             *
             * Both gestures must have been added to the same widget before
             * they can be grouped.
             *
             * When gestures are grouped, the state of `GdkEventSequences`
             * is kept in sync for all of those, so calling
             * [method`Gtk`.Gesture.set_sequence_state], on one will transfer
             * the same value to the others.
             *
             * Groups also perform an "implicit grabbing" of sequences, if a
             * `GdkEventSequence` state is set to %GTK_EVENT_SEQUENCE_CLAIMED
             * on one group, every other gesture group attached to the same
             * `GtkWidget` will switch the state for that sequence to
             * %GTK_EVENT_SEQUENCE_DENIED.
             * @param gesture a `GtkGesture`
             */
            group(gesture: Gesture): void;
            /**
             * Returns %TRUE if `gesture` is currently handling events
             * corresponding to `sequence`.
             * @param sequence a `GdkEventSequence`
             * @returns %TRUE if @gesture is handling @sequence, %FALSE otherwise
             */
            handles_sequence(sequence?: Gdk.EventSequence | null): boolean;
            /**
             * Returns %TRUE if the gesture is currently active.
             *
             * A gesture is active while there are touch sequences
             * interacting with it.
             * @returns %TRUE if gesture is active
             */
            is_active(): boolean;
            /**
             * Returns %TRUE if both gestures pertain to the same group.
             * @param other another `GtkGesture`
             * @returns whether the gestures are grouped
             */
            is_grouped_with(other: Gesture): boolean;
            /**
             * Returns %TRUE if the gesture is currently recognized.
             *
             * A gesture is recognized if there are as many interacting
             * touch sequences as required by `gesture`.
             * @returns %TRUE if gesture is recognized
             */
            is_recognized(): boolean;
            /**
             * Sets the state of `sequence` in `gesture`.
             *
             * Sequences start in state %GTK_EVENT_SEQUENCE_NONE, and whenever
             * they change state, they can never go back to that state. Likewise,
             * sequences in state %GTK_EVENT_SEQUENCE_DENIED cannot turn back to
             * a not denied state. With these rules, the lifetime of an event
             * sequence is constrained to the next four:
             *
             * * None
             * * None → Denied
             * * None → Claimed
             * * None → Claimed → Denied
             *
             * Note: Due to event handling ordering, it may be unsafe to set the
             * state on another gesture within a [signal`Gtk`.Gesture::begin] signal
             * handler, as the callback might be executed before the other gesture
             * knows about the sequence. A safe way to perform this could be:
             *
             * ```c
             * static void
             * first_gesture_begin_cb (GtkGesture       *first_gesture,
             *                         GdkEventSequence *sequence,
             *                         gpointer          user_data)
             * {
             *   gtk_gesture_set_sequence_state (first_gesture, sequence, GTK_EVENT_SEQUENCE_CLAIMED);
             *   gtk_gesture_set_sequence_state (second_gesture, sequence, GTK_EVENT_SEQUENCE_DENIED);
             * }
             *
             * static void
             * second_gesture_begin_cb (GtkGesture       *second_gesture,
             *                          GdkEventSequence *sequence,
             *                          gpointer          user_data)
             * {
             *   if (gtk_gesture_get_sequence_state (first_gesture, sequence) == GTK_EVENT_SEQUENCE_CLAIMED)
             *     gtk_gesture_set_sequence_state (second_gesture, sequence, GTK_EVENT_SEQUENCE_DENIED);
             * }
             * ```
             *
             * If both gestures are in the same group, just set the state on
             * the gesture emitting the event, the sequence will be already
             * be initialized to the group's global state when the second
             * gesture processes the event.
             * @param sequence a `GdkEventSequence`
             * @param state the sequence state
             * @returns %TRUE if @sequence is handled by @gesture,   and the state is changed successfully
             */
            set_sequence_state(sequence: Gdk.EventSequence, state: EventSequenceState | null): boolean;
            /**
             * Sets the state of all sequences that `gesture` is currently
             * interacting with.
             *
             * Sequences start in state %GTK_EVENT_SEQUENCE_NONE, and whenever
             * they change state, they can never go back to that state. Likewise,
             * sequences in state %GTK_EVENT_SEQUENCE_DENIED cannot turn back to
             * a not denied state. With these rules, the lifetime of an event
             * sequence is constrained to the next four:
             *
             * * None
             * * None → Denied
             * * None → Claimed
             * * None → Claimed → Denied
             *
             * Note: Due to event handling ordering, it may be unsafe to set the
             * state on another gesture within a [signal`Gtk`.Gesture::begin] signal
             * handler, as the callback might be executed before the other gesture
             * knows about the sequence. A safe way to perform this could be:
             *
             * ```c
             * static void
             * first_gesture_begin_cb (GtkGesture       *first_gesture,
             *                         GdkEventSequence *sequence,
             *                         gpointer          user_data)
             * {
             *   gtk_gesture_set_state (first_gesture, GTK_EVENT_SEQUENCE_CLAIMED);
             *   gtk_gesture_set_state (second_gesture, GTK_EVENT_SEQUENCE_DENIED);
             * }
             *
             * static void
             * second_gesture_begin_cb (GtkGesture       *second_gesture,
             *                          GdkEventSequence *sequence,
             *                          gpointer          user_data)
             * {
             *   if (gtk_gesture_get_sequence_state (first_gesture, sequence) == GTK_EVENT_SEQUENCE_CLAIMED)
             *     gtk_gesture_set_state (second_gesture, GTK_EVENT_SEQUENCE_DENIED);
             * }
             * ```
             *
             * If both gestures are in the same group, just set the state on
             * the gesture emitting the event, the sequence will be already
             * be initialized to the group's global state when the second
             * gesture processes the event.
             * @param state the sequence state
             * @returns %TRUE if the state of at least one sequence   was changed successfully
             */
            set_state(state: EventSequenceState | null): boolean;
            /**
             * Separates `gesture` into an isolated group.
             */
            ungroup(): void;
        }

        namespace GestureClick {
            // Signal callback interfaces

            interface Pressed {
                (n_press: number, x: number, y: number): void;
            }

            interface Released {
                (n_press: number, x: number, y: number): void;
            }

            interface Stopped {
                (): void;
            }

            interface UnpairedRelease {
                (x: number, y: number, button: number, sequence?: Gdk.EventSequence | null): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GestureSingle.ConstructorProps {}
        }

        /**
         * `GtkGestureClick` is a `GtkGesture` implementation for clicks.
         *
         * It is able to recognize multiple clicks on a nearby zone, which
         * can be listened for through the [signal`Gtk`.GestureClick::pressed]
         * signal. Whenever time or distance between clicks exceed the GTK
         * defaults, [signal`Gtk`.GestureClick::stopped] is emitted, and the
         * click counter is reset.
         */
        class GestureClick extends GestureSingle {
            static $gtype: GObject.GType<GestureClick>;

            // Constructors

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

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

            static ['new'](): GestureClick;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(
                signal: 'pressed',
                callback: (_source: this, n_press: number, x: number, y: number) => void,
            ): number;
            connect_after(
                signal: 'pressed',
                callback: (_source: this, n_press: number, x: number, y: number) => void,
            ): number;
            emit(signal: 'pressed', n_press: number, x: number, y: number): void;
            connect(
                signal: 'released',
                callback: (_source: this, n_press: number, x: number, y: number) => void,
            ): number;
            connect_after(
                signal: 'released',
                callback: (_source: this, n_press: number, x: number, y: number) => void,
            ): number;
            emit(signal: 'released', n_press: number, x: number, y: number): void;
            connect(signal: 'stopped', callback: (_source: this) => void): number;
            connect_after(signal: 'stopped', callback: (_source: this) => void): number;
            emit(signal: 'stopped'): void;
            connect(
                signal: 'unpaired-release',
                callback: (
                    _source: this,
                    x: number,
                    y: number,
                    button: number,
                    sequence: Gdk.EventSequence | null,
                ) => void,
            ): number;
            connect_after(
                signal: 'unpaired-release',
                callback: (
                    _source: this,
                    x: number,
                    y: number,
                    button: number,
                    sequence: Gdk.EventSequence | null,
                ) => void,
            ): number;
            emit(
                signal: 'unpaired-release',
                x: number,
                y: number,
                button: number,
                sequence?: Gdk.EventSequence | null,
            ): void;
        }

        namespace GestureDrag {
            // Signal callback interfaces

            interface DragBegin {
                (start_x: number, start_y: number): void;
            }

            interface DragEnd {
                (offset_x: number, offset_y: number): void;
            }

            interface DragUpdate {
                (offset_x: number, offset_y: number): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GestureSingle.ConstructorProps {}
        }

        /**
         * `GtkGestureDrag` is a `GtkGesture` implementation for drags.
         *
         * The drag operation itself can be tracked throughout the
         * [signal`Gtk`.GestureDrag::drag-begin],
         * [signal`Gtk`.GestureDrag::drag-update] and
         * [signal`Gtk`.GestureDrag::drag-end] signals, and the relevant
         * coordinates can be extracted through
         * [method`Gtk`.GestureDrag.get_offset] and
         * [method`Gtk`.GestureDrag.get_start_point].
         */
        class GestureDrag extends GestureSingle {
            static $gtype: GObject.GType<GestureDrag>;

            // Constructors

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

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

            static ['new'](): GestureDrag;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'drag-begin', callback: (_source: this, start_x: number, start_y: number) => void): number;
            connect_after(
                signal: 'drag-begin',
                callback: (_source: this, start_x: number, start_y: number) => void,
            ): number;
            emit(signal: 'drag-begin', start_x: number, start_y: number): void;
            connect(signal: 'drag-end', callback: (_source: this, offset_x: number, offset_y: number) => void): number;
            connect_after(
                signal: 'drag-end',
                callback: (_source: this, offset_x: number, offset_y: number) => void,
            ): number;
            emit(signal: 'drag-end', offset_x: number, offset_y: number): void;
            connect(
                signal: 'drag-update',
                callback: (_source: this, offset_x: number, offset_y: number) => void,
            ): number;
            connect_after(
                signal: 'drag-update',
                callback: (_source: this, offset_x: number, offset_y: number) => void,
            ): number;
            emit(signal: 'drag-update', offset_x: number, offset_y: number): void;

            // Methods

            /**
             * Gets the offset from the start point.
             *
             * If the `gesture` is active, this function returns %TRUE and
             * fills in `x` and `y` with the coordinates of the current point,
             * as an offset to the starting drag point.
             * @returns %TRUE if the gesture is active
             */
            get_offset(): [boolean, number, number];
            /**
             * Gets the point where the drag started.
             *
             * If the `gesture` is active, this function returns %TRUE
             * and fills in `x` and `y` with the drag start coordinates,
             * in widget-relative coordinates.
             * @returns %TRUE if the gesture is active
             */
            get_start_point(): [boolean, number, number];
        }

        namespace GestureLongPress {
            // Signal callback interfaces

            interface Cancelled {
                (): void;
            }

            interface Pressed {
                (x: number, y: number): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GestureSingle.ConstructorProps {
                delay_factor: number;
                delayFactor: number;
            }
        }

        /**
         * `GtkGestureLongPress` is a `GtkGesture` for long presses.
         *
         * This gesture is also known as “Press and Hold”.
         *
         * When the timeout is exceeded, the gesture is triggering the
         * [signal`Gtk`.GestureLongPress::pressed] signal.
         *
         * If the touchpoint is lifted before the timeout passes, or if
         * it drifts too far of the initial press point, the
         * [signal`Gtk`.GestureLongPress::cancelled] signal will be emitted.
         *
         * How long the timeout is before the ::pressed signal gets emitted is
         * determined by the [property`Gtk`.Settings:gtk-long-press-time] setting.
         * It can be modified by the [property`Gtk`.GestureLongPress:delay-factor]
         * property.
         */
        class GestureLongPress extends GestureSingle {
            static $gtype: GObject.GType<GestureLongPress>;

            // Properties

            /**
             * Factor by which to modify the default timeout.
             */
            get delay_factor(): number;
            set delay_factor(val: number);
            /**
             * Factor by which to modify the default timeout.
             */
            get delayFactor(): number;
            set delayFactor(val: number);

            // Constructors

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

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

            static ['new'](): GestureLongPress;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'cancelled', callback: (_source: this) => void): number;
            connect_after(signal: 'cancelled', callback: (_source: this) => void): number;
            emit(signal: 'cancelled'): void;
            connect(signal: 'pressed', callback: (_source: this, x: number, y: number) => void): number;
            connect_after(signal: 'pressed', callback: (_source: this, x: number, y: number) => void): number;
            emit(signal: 'pressed', x: number, y: number): void;

            // Methods

            /**
             * Returns the delay factor.
             * @returns the delay factor
             */
            get_delay_factor(): number;
            /**
             * Applies the given delay factor.
             *
             * The default long press time will be multiplied by this value.
             * Valid values are in the range [0.5..2.0].
             * @param delay_factor The delay factor to apply
             */
            set_delay_factor(delay_factor: number): void;
        }

        namespace GesturePan {
            // Signal callback interfaces

            interface Pan {
                (direction: PanDirection, offset: number): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GestureDrag.ConstructorProps {
                orientation: Orientation;
            }
        }

        /**
         * `GtkGesturePan` is a `GtkGesture` for pan gestures.
         *
         * These are drags that are locked to happen along one axis. The axis
         * that a `GtkGesturePan` handles is defined at construct time, and
         * can be changed through [method`Gtk`.GesturePan.set_orientation].
         *
         * When the gesture starts to be recognized, `GtkGesturePan` will
         * attempt to determine as early as possible whether the sequence
         * is moving in the expected direction, and denying the sequence if
         * this does not happen.
         *
         * Once a panning gesture along the expected axis is recognized,
         * the [signal`Gtk`.GesturePan::pan] signal will be emitted as input
         * events are received, containing the offset in the given axis.
         */
        class GesturePan extends GestureDrag {
            static $gtype: GObject.GType<GesturePan>;

            // Properties

            /**
             * The expected orientation of pan gestures.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Constructors

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

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

            static ['new'](orientation: Orientation): GesturePan;
            // Conflicted with Gtk.GestureDrag.new

            static ['new'](...args: never[]): any;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'pan', callback: (_source: this, direction: PanDirection, offset: number) => void): number;
            connect_after(
                signal: 'pan',
                callback: (_source: this, direction: PanDirection, offset: number) => void,
            ): number;
            emit(signal: 'pan', direction: PanDirection, offset: number): void;

            // Methods

            /**
             * Returns the orientation of the pan gestures that this `gesture` expects.
             * @returns the expected orientation for pan gestures
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation to be expected on pan gestures.
             * @param orientation expected orientation
             */
            set_orientation(orientation: Orientation | null): void;
        }

        namespace GestureRotate {
            // Signal callback interfaces

            interface AngleChanged {
                (angle: number, angle_delta: number): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends Gesture.ConstructorProps {}
        }

        /**
         * `GtkGestureRotate` is a `GtkGesture` for 2-finger rotations.
         *
         * Whenever the angle between both handled sequences changes, the
         * [signal`Gtk`.GestureRotate::angle-changed] signal is emitted.
         */
        class GestureRotate extends Gesture {
            static $gtype: GObject.GType<GestureRotate>;

            // Constructors

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

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

            static ['new'](): GestureRotate;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(
                signal: 'angle-changed',
                callback: (_source: this, angle: number, angle_delta: number) => void,
            ): number;
            connect_after(
                signal: 'angle-changed',
                callback: (_source: this, angle: number, angle_delta: number) => void,
            ): number;
            emit(signal: 'angle-changed', angle: number, angle_delta: number): void;

            // Methods

            /**
             * Gets the angle delta in radians.
             *
             * If `gesture` is active, this function returns the angle difference
             * in radians since the gesture was first recognized. If `gesture` is
             * not active, 0 is returned.
             * @returns the angle delta in radians
             */
            get_angle_delta(): number;
        }

        namespace GestureSingle {
            // Constructor properties interface

            interface ConstructorProps extends Gesture.ConstructorProps {
                button: number;
                exclusive: boolean;
                touch_only: boolean;
                touchOnly: boolean;
            }
        }

        /**
         * `GtkGestureSingle` is a `GtkGestures` subclass optimized for singe-touch
         * and mouse gestures.
         *
         * Under interaction, these gestures stick to the first interacting sequence,
         * which is accessible through [method`Gtk`.GestureSingle.get_current_sequence]
         * while the gesture is being interacted with.
         *
         * By default gestures react to both %GDK_BUTTON_PRIMARY and touch events.
         * [method`Gtk`.GestureSingle.set_touch_only] can be used to change the
         * touch behavior. Callers may also specify a different mouse button number
         * to interact with through [method`Gtk`.GestureSingle.set_button], or react
         * to any mouse button by setting it to 0. While the gesture is active, the
         * button being currently pressed can be known through
         * [method`Gtk`.GestureSingle.get_current_button].
         */
        class GestureSingle extends Gesture {
            static $gtype: GObject.GType<GestureSingle>;

            // Properties

            /**
             * Mouse button number to listen to, or 0 to listen for any button.
             */
            get button(): number;
            set button(val: number);
            /**
             * Whether the gesture is exclusive.
             *
             * Exclusive gestures only listen to pointer and pointer emulated events.
             */
            get exclusive(): boolean;
            set exclusive(val: boolean);
            /**
             * Whether the gesture handles only touch events.
             */
            get touch_only(): boolean;
            set touch_only(val: boolean);
            /**
             * Whether the gesture handles only touch events.
             */
            get touchOnly(): boolean;
            set touchOnly(val: boolean);

            // Constructors

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

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

            // Methods

            /**
             * Returns the button number `gesture` listens for.
             *
             * If this is 0, the gesture reacts to any button press.
             * @returns The button number, or 0 for any button
             */
            get_button(): number;
            /**
             * Returns the button number currently interacting
             * with `gesture,` or 0 if there is none.
             * @returns The current button number
             */
            get_current_button(): number;
            /**
             * Returns the event sequence currently interacting with `gesture`.
             *
             * This is only meaningful if [method`Gtk`.Gesture.is_active]
             * returns %TRUE.
             * @returns the current sequence
             */
            get_current_sequence(): Gdk.EventSequence | null;
            /**
             * Gets whether a gesture is exclusive.
             *
             * For more information, see [method`Gtk`.GestureSingle.set_exclusive].
             * @returns Whether the gesture is exclusive
             */
            get_exclusive(): boolean;
            /**
             * Returns %TRUE if the gesture is only triggered by touch events.
             * @returns %TRUE if the gesture only handles touch events
             */
            get_touch_only(): boolean;
            /**
             * Sets the button number `gesture` listens to.
             *
             * If non-0, every button press from a different button
             * number will be ignored. Touch events implicitly match
             * with button 1.
             * @param button button number to listen to, or 0 for any button
             */
            set_button(button: number): void;
            /**
             * Sets whether `gesture` is exclusive.
             *
             * An exclusive gesture will only handle pointer and "pointer emulated"
             * touch events, so at any given time, there is only one sequence able
             * to interact with those.
             * @param exclusive %TRUE to make @gesture exclusive
             */
            set_exclusive(exclusive: boolean): void;
            /**
             * Sets whether to handle only touch events.
             *
             * If `touch_only` is %TRUE, `gesture` will only handle events of type
             * %GDK_TOUCH_BEGIN, %GDK_TOUCH_UPDATE or %GDK_TOUCH_END. If %FALSE,
             * mouse events will be handled too.
             * @param touch_only whether @gesture handles only touch events
             */
            set_touch_only(touch_only: boolean): void;
        }

        namespace GestureStylus {
            // Signal callback interfaces

            interface Down {
                (x: number, y: number): void;
            }

            interface Motion {
                (x: number, y: number): void;
            }

            interface Proximity {
                (x: number, y: number): void;
            }

            interface Up {
                (x: number, y: number): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GestureSingle.ConstructorProps {
                stylus_only: boolean;
                stylusOnly: boolean;
            }
        }

        /**
         * `GtkGestureStylus` is a `GtkGesture` specific to stylus input.
         *
         * The provided signals just relay the basic information of the
         * stylus events.
         */
        class GestureStylus extends GestureSingle {
            static $gtype: GObject.GType<GestureStylus>;

            // Properties

            /**
             * If this gesture should exclusively react to stylus input devices.
             */
            get stylus_only(): boolean;
            set stylus_only(val: boolean);
            /**
             * If this gesture should exclusively react to stylus input devices.
             */
            get stylusOnly(): boolean;
            set stylusOnly(val: boolean);

            // Constructors

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

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

            static ['new'](): GestureStylus;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'down', callback: (_source: this, x: number, y: number) => void): number;
            connect_after(signal: 'down', callback: (_source: this, x: number, y: number) => void): number;
            emit(signal: 'down', x: number, y: number): void;
            connect(signal: 'motion', callback: (_source: this, x: number, y: number) => void): number;
            connect_after(signal: 'motion', callback: (_source: this, x: number, y: number) => void): number;
            emit(signal: 'motion', x: number, y: number): void;
            connect(signal: 'proximity', callback: (_source: this, x: number, y: number) => void): number;
            connect_after(signal: 'proximity', callback: (_source: this, x: number, y: number) => void): number;
            emit(signal: 'proximity', x: number, y: number): void;
            connect(signal: 'up', callback: (_source: this, x: number, y: number) => void): number;
            connect_after(signal: 'up', callback: (_source: this, x: number, y: number) => void): number;
            emit(signal: 'up', x: number, y: number): void;

            // Methods

            /**
             * Returns the current values for the requested `axes`.
             *
             * This function must be called from the handler of one of the
             * [signal`Gtk`.GestureStylus::down], [signal`Gtk`.GestureStylus::motion],
             * [signal`Gtk`.GestureStylus::up] or [signal`Gtk`.GestureStylus::proximity]
             * signals.
             * @param axes array of requested axes, terminated with %GDK_AXIS_IGNORE
             * @returns %TRUE if there is a current value for the axes
             */
            get_axes(axes: Gdk.AxisUse[] | null): [boolean, number[]];
            /**
             * Returns the current value for the requested `axis`.
             *
             * This function must be called from the handler of one of the
             * [signal`Gtk`.GestureStylus::down], [signal`Gtk`.GestureStylus::motion],
             * [signal`Gtk`.GestureStylus::up] or [signal`Gtk`.GestureStylus::proximity]
             * signals.
             * @param axis requested device axis
             * @returns %TRUE if there is a current value for the axis
             */
            get_axis(axis: Gdk.AxisUse | null): [boolean, number];
            /**
             * Returns the accumulated backlog of tracking information.
             *
             * By default, GTK will limit rate of input events. On stylus input
             * where accuracy of strokes is paramount, this function returns the
             * accumulated coordinate/timing state before the emission of the
             * current [Gtk.GestureStylus::motion] signal.
             *
             * This function may only be called within a [signal`Gtk`.GestureStylus::motion]
             * signal handler, the state given in this signal and obtainable through
             * [method`Gtk`.GestureStylus.get_axis] express the latest (most up-to-date)
             * state in motion history.
             *
             * The `backlog` is provided in chronological order.
             * @returns %TRUE if there is a backlog to unfold in the current state.
             */
            get_backlog(): [boolean, Gdk.TimeCoord[]];
            /**
             * Returns the `GdkDeviceTool` currently driving input through this gesture.
             *
             * This function must be called from the handler of one of the
             * [signal`Gtk`.GestureStylus::down], [signal`Gtk`.GestureStylus::motion],
             * [signal`Gtk`.GestureStylus::up] or [signal`Gtk`.GestureStylus::proximity]
             * signals.
             * @returns The current stylus tool
             */
            get_device_tool(): Gdk.DeviceTool | null;
            /**
             * Checks whether the gesture is for styluses only.
             *
             * Stylus-only gestures will signal events exclusively from stylus
             * input devices.
             * @returns %TRUE if the gesture is only for stylus events
             */
            get_stylus_only(): boolean;
            /**
             * Sets the state of stylus-only
             *
             * If true, the gesture will exclusively handle events from stylus input devices,
             * otherwise it'll handle events from any pointing device.
             * @param stylus_only whether the gesture is used exclusively for stylus events
             */
            set_stylus_only(stylus_only: boolean): void;
        }

        namespace GestureSwipe {
            // Signal callback interfaces

            interface Swipe {
                (velocity_x: number, velocity_y: number): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GestureSingle.ConstructorProps {}
        }

        /**
         * `GtkGestureSwipe` is a `GtkGesture` for swipe gestures.
         *
         * After a press/move/.../move/release sequence happens, the
         * [signal`Gtk`.GestureSwipe::swipe] signal will be emitted,
         * providing the velocity and directionality of the sequence
         * at the time it was lifted.
         *
         * If the velocity is desired in intermediate points,
         * [method`Gtk`.GestureSwipe.get_velocity] can be called in a
         * [signal`Gtk`.Gesture::update] handler.
         *
         * All velocities are reported in pixels/sec units.
         */
        class GestureSwipe extends GestureSingle {
            static $gtype: GObject.GType<GestureSwipe>;

            // Constructors

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

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

            static ['new'](): GestureSwipe;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'swipe', callback: (_source: this, velocity_x: number, velocity_y: number) => void): number;
            connect_after(
                signal: 'swipe',
                callback: (_source: this, velocity_x: number, velocity_y: number) => void,
            ): number;
            emit(signal: 'swipe', velocity_x: number, velocity_y: number): void;

            // Methods

            /**
             * Gets the current velocity.
             *
             * If the gesture is recognized, this function returns %TRUE and fills
             * in `velocity_x` and `velocity_y` with the recorded velocity, as per the
             * last events processed.
             * @returns whether velocity could be calculated
             */
            get_velocity(): [boolean, number, number];
        }

        namespace GestureZoom {
            // Signal callback interfaces

            interface ScaleChanged {
                (scale: number): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends Gesture.ConstructorProps {}
        }

        /**
         * `GtkGestureZoom` is a `GtkGesture` for 2-finger pinch/zoom gestures.
         *
         * Whenever the distance between both tracked sequences changes, the
         * [signal`Gtk`.GestureZoom::scale-changed] signal is emitted to report
         * the scale factor.
         */
        class GestureZoom extends Gesture {
            static $gtype: GObject.GType<GestureZoom>;

            // Constructors

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

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

            static ['new'](): GestureZoom;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'scale-changed', callback: (_source: this, scale: number) => void): number;
            connect_after(signal: 'scale-changed', callback: (_source: this, scale: number) => void): number;
            emit(signal: 'scale-changed', scale: number): void;

            // Methods

            /**
             * Gets the scale delta.
             *
             * If `gesture` is active, this function returns the zooming
             * difference since the gesture was recognized (hence the
             * starting point is considered 1:1). If `gesture` is not
             * active, 1 is returned.
             * @returns the scale delta
             */
            get_scale_delta(): number;
        }

        namespace GraphicsOffload {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                black_background: boolean;
                blackBackground: boolean;
                child: Widget;
                enabled: GraphicsOffloadEnabled;
            }
        }

        /**
         * A widget that allows to bypass gsk rendering for its child by passing the content
         * directly to the compositor.
         *
         * Graphics offload is an optimization to reduce overhead and battery use that is
         * most useful for video content. It only works on some platforms and in certain
         * situations. GTK will automatically fall back to normal rendering if it doesn't.
         *
         * Graphics offload is most efficient if there are no controls drawn on top of the
         * video content.
         *
         * You should consider using graphics offload for your main widget if it shows
         * frequently changing content (such as a video, or a VM display) and you provide
         * the content in the form of dmabuf textures (see [class`Gdk`.DmabufTextureBuilder]),
         * in particular if it may be fullscreen.
         *
         * Numerous factors can prohibit graphics offload:
         *
         * - Unsupported platforms. Currently, graphics offload only works on Linux with Wayland.
         *
         * - Clipping, such as rounded corners that cause the video content to not be rectangular
         *
         * - Unsupported dmabuf formats (see [method`Gdk`.Display.get_dmabuf_formats])
         *
         * - Translucent video content (content with an alpha channel, even if it isn't used)
         *
         * - Transforms that are more complex than translations and scales
         *
         * - Filters such as opacity, grayscale or similar
         *
         * To investigate problems related graphics offload, GTK offers debug flags to print
         * out information about graphics offload and dmabuf use:
         *
         *     GDK_DEBUG=offload
         *     GDK_DEBUG=dmabuf
         *
         * The GTK inspector provides a visual debugging tool for graphics offload.
         */
        class GraphicsOffload extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<GraphicsOffload>;

            // Properties

            /**
             * Whether to draw a black background.
             */
            get black_background(): boolean;
            set black_background(val: boolean);
            /**
             * Whether to draw a black background.
             */
            get blackBackground(): boolean;
            set blackBackground(val: boolean);
            /**
             * The child widget.
             */
            get child(): Widget;
            set child(val: Widget);
            /**
             * Whether graphics offload is enabled.
             */
            get enabled(): GraphicsOffloadEnabled;
            set enabled(val: GraphicsOffloadEnabled);

            // Constructors

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

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

            static ['new'](child?: Widget | null): GraphicsOffload;

            // Methods

            /**
             * Returns whether the widget draws a black background.
             *
             * See [method`Gtk`.GraphicsOffload.set_black_background].
             * @returns `TRUE` if black background is drawn
             */
            get_black_background(): boolean;
            /**
             * Gets the child of `self`.
             * @returns the child widget
             */
            get_child(): Widget | null;
            /**
             * Returns whether offload is enabled for `self`.
             * @returns whether offload is enabled
             */
            get_enabled(): GraphicsOffloadEnabled;
            /**
             * Sets whether this GtkGraphicsOffload widget will draw a black
             * background.
             *
             * A main use case for this is **_letterboxing_** where black bars are
             * visible next to the content if the aspect ratio of the content does
             * not match the dimensions of the monitor.
             *
             * Using this property for letterboxing instead of CSS allows compositors
             * to show content with maximum efficiency, using direct scanout to avoid
             * extra copies in the compositor.
             *
             * On Wayland, this is implemented using the
             * [single-pixel buffer](https://wayland.app/protocols/single-pixel-buffer-v1)
             * protocol.
             * @param value whether to draw a black background behind the content
             */
            set_black_background(value: boolean): void;
            /**
             * Sets the child of `self`.
             * @param child the child widget
             */
            set_child(child?: Widget | null): void;
            /**
             * Sets whether this GtkGraphicsOffload widget will attempt
             * to offload the content of its child widget.
             * @param enabled whether to enable offload
             */
            set_enabled(enabled: GraphicsOffloadEnabled | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Grid {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Orientable.ConstructorProps {
                baseline_row: number;
                baselineRow: number;
                column_homogeneous: boolean;
                columnHomogeneous: boolean;
                column_spacing: number;
                columnSpacing: number;
                row_homogeneous: boolean;
                rowHomogeneous: boolean;
                row_spacing: number;
                rowSpacing: number;
            }
        }

        /**
         * `GtkGrid` is a container which arranges its child widgets in
         * rows and columns.
         *
         * ![An example GtkGrid](grid.png)
         *
         * It supports arbitrary positions and horizontal/vertical spans.
         *
         * Children are added using [method`Gtk`.Grid.attach]. They can span multiple
         * rows or columns. It is also possible to add a child next to an existing
         * child, using [method`Gtk`.Grid.attach_next_to]. To remove a child from the
         * grid, use [method`Gtk`.Grid.remove].
         *
         * The behaviour of `GtkGrid` when several children occupy the same grid
         * cell is undefined.
         *
         * # GtkGrid as GtkBuildable
         *
         * Every child in a `GtkGrid` has access to a custom [iface`Gtk`.Buildable]
         * element, called `<layout>`. It can by used to specify a position in the
         * grid and optionally spans. All properties that can be used in the `<layout>`
         * element are implemented by [class`Gtk`.GridLayoutChild].
         *
         * It is implemented by `GtkWidget` using [class`Gtk`.LayoutManager].
         *
         * To showcase it, here is a simple example:
         *
         * ```xml
         * <object class="GtkGrid" id="my_grid">
         *   <child>
         *     <object class="GtkButton" id="button1">
         *       <property name="label">Button 1</property>
         *       <layout>
         *         <property name="column">0</property>
         *         <property name="row">0</property>
         *       </layout>
         *     </object>
         *   </child>
         *   <child>
         *     <object class="GtkButton" id="button2">
         *       <property name="label">Button 2</property>
         *       <layout>
         *         <property name="column">1</property>
         *         <property name="row">0</property>
         *       </layout>
         *     </object>
         *   </child>
         *   <child>
         *     <object class="GtkButton" id="button3">
         *       <property name="label">Button 3</property>
         *       <layout>
         *         <property name="column">2</property>
         *         <property name="row">0</property>
         *         <property name="row-span">2</property>
         *       </layout>
         *     </object>
         *   </child>
         *   <child>
         *     <object class="GtkButton" id="button4">
         *       <property name="label">Button 4</property>
         *       <layout>
         *         <property name="column">0</property>
         *         <property name="row">1</property>
         *         <property name="column-span">2</property>
         *       </layout>
         *     </object>
         *   </child>
         * </object>
         * ```
         *
         * It organizes the first two buttons side-by-side in one cell each.
         * The third button is in the last column but spans across two rows.
         * This is defined by the `row-span` property. The last button is
         * located in the second row and spans across two columns, which is
         * defined by the `column-span` property.
         *
         * # CSS nodes
         *
         * `GtkGrid` uses a single CSS node with name `grid`.
         *
         * # Accessibility
         *
         * Until GTK 4.10, `GtkGrid` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
         *
         * Starting from GTK 4.12, `GtkGrid` uses the `GTK_ACCESSIBLE_ROLE_GENERIC` role.
         */
        class Grid extends Widget implements Accessible, Buildable, ConstraintTarget, Orientable {
            static $gtype: GObject.GType<Grid>;

            // Properties

            /**
             * The row to align to the baseline when valign is using baseline alignment.
             */
            get baseline_row(): number;
            set baseline_row(val: number);
            /**
             * The row to align to the baseline when valign is using baseline alignment.
             */
            get baselineRow(): number;
            set baselineRow(val: number);
            /**
             * If %TRUE, the columns are all the same width.
             */
            get column_homogeneous(): boolean;
            set column_homogeneous(val: boolean);
            /**
             * If %TRUE, the columns are all the same width.
             */
            get columnHomogeneous(): boolean;
            set columnHomogeneous(val: boolean);
            /**
             * The amount of space between two consecutive columns.
             */
            get column_spacing(): number;
            set column_spacing(val: number);
            /**
             * The amount of space between two consecutive columns.
             */
            get columnSpacing(): number;
            set columnSpacing(val: number);
            /**
             * If %TRUE, the rows are all the same height.
             */
            get row_homogeneous(): boolean;
            set row_homogeneous(val: boolean);
            /**
             * If %TRUE, the rows are all the same height.
             */
            get rowHomogeneous(): boolean;
            set rowHomogeneous(val: boolean);
            /**
             * The amount of space between two consecutive rows.
             */
            get row_spacing(): number;
            set row_spacing(val: number);
            /**
             * The amount of space between two consecutive rows.
             */
            get rowSpacing(): number;
            set rowSpacing(val: number);

            // Constructors

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

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

            static ['new'](): Grid;

            // Methods

            /**
             * Adds a widget to the grid.
             *
             * The position of `child` is determined by `column` and `row`.
             * The number of “cells” that `child` will occupy is determined
             * by `width` and `height`.
             * @param child the widget to add
             * @param column the column number to attach the left side of @child to
             * @param row the row number to attach the top side of @child to
             * @param width the number of columns that @child will span
             * @param height the number of rows that @child will span
             */
            attach(child: Widget, column: number, row: number, width: number, height: number): void;
            /**
             * Adds a widget to the grid.
             *
             * The widget is placed next to `sibling,` on the side determined by
             * `side`. When `sibling` is %NULL, the widget is placed in row (for
             * left or right placement) or column 0 (for top or bottom placement),
             * at the end indicated by `side`.
             *
             * Attaching widgets labeled `[1]`, `[2]`, `[3]` with ``sibling` == %NULL` and
             * ``side` == %GTK_POS_LEFT` yields a layout of `[3][2][1]`.
             * @param child the widget to add
             * @param sibling the child of @grid that @child will be placed   next to, or %NULL to place @child at the beginning or end
             * @param side the side of @sibling that @child is positioned next to
             * @param width the number of columns that @child will span
             * @param height the number of rows that @child will span
             */
            attach_next_to(
                child: Widget,
                sibling: Widget | null,
                side: PositionType | null,
                width: number,
                height: number,
            ): void;
            /**
             * Returns which row defines the global baseline of `grid`.
             * @returns the row index defining the global baseline
             */
            get_baseline_row(): number;
            /**
             * Gets the child of `grid` whose area covers the grid
             * cell at `column,` `row`.
             * @param column the left edge of the cell
             * @param row the top edge of the cell
             * @returns the child at the given position
             */
            get_child_at(column: number, row: number): Widget | null;
            /**
             * Returns whether all columns of `grid` have the same width.
             * @returns whether all columns of @grid have the same width.
             */
            get_column_homogeneous(): boolean;
            /**
             * Returns the amount of space between the columns of `grid`.
             * @returns the column spacing of @grid
             */
            get_column_spacing(): number;
            /**
             * Returns the baseline position of `row`.
             *
             * See [method`Gtk`.Grid.set_row_baseline_position].
             * @param row a row index
             * @returns the baseline position of @row
             */
            get_row_baseline_position(row: number): BaselinePosition;
            /**
             * Returns whether all rows of `grid` have the same height.
             * @returns whether all rows of @grid have the same height.
             */
            get_row_homogeneous(): boolean;
            /**
             * Returns the amount of space between the rows of `grid`.
             * @returns the row spacing of @grid
             */
            get_row_spacing(): number;
            /**
             * Inserts a column at the specified position.
             *
             * Children which are attached at or to the right of this position
             * are moved one column to the right. Children which span across this
             * position are grown to span the new column.
             * @param position the position to insert the column at
             */
            insert_column(position: number): void;
            /**
             * Inserts a row or column at the specified position.
             *
             * The new row or column is placed next to `sibling,` on the side
             * determined by `side`. If `side` is %GTK_POS_TOP or %GTK_POS_BOTTOM,
             * a row is inserted. If `side` is %GTK_POS_LEFT of %GTK_POS_RIGHT,
             * a column is inserted.
             * @param sibling the child of @grid that the new row or column will be   placed next to
             * @param side the side of @sibling that @child is positioned next to
             */
            insert_next_to(sibling: Widget, side: PositionType | null): void;
            /**
             * Inserts a row at the specified position.
             *
             * Children which are attached at or below this position
             * are moved one row down. Children which span across this
             * position are grown to span the new row.
             * @param position the position to insert the row at
             */
            insert_row(position: number): void;
            /**
             * Queries the attach points and spans of `child` inside the given `GtkGrid`.
             * @param child a `GtkWidget` child of @grid
             */
            query_child(child: Widget): [number, number, number, number];
            /**
             * Removes a child from `grid`.
             *
             * The child must have been added with
             * [method`Gtk`.Grid.attach] or [method`Gtk`.Grid.attach_next_to].
             * @param child the child widget to remove
             */
            remove(child: Widget): void;
            /**
             * Removes a column from the grid.
             *
             * Children that are placed in this column are removed,
             * spanning children that overlap this column have their
             * width reduced by one, and children after the column
             * are moved to the left.
             * @param position the position of the column to remove
             */
            remove_column(position: number): void;
            /**
             * Removes a row from the grid.
             *
             * Children that are placed in this row are removed,
             * spanning children that overlap this row have their
             * height reduced by one, and children below the row
             * are moved up.
             * @param position the position of the row to remove
             */
            remove_row(position: number): void;
            /**
             * Sets which row defines the global baseline for the entire grid.
             *
             * Each row in the grid can have its own local baseline, but only
             * one of those is global, meaning it will be the baseline in the
             * parent of the `grid`.
             * @param row the row index
             */
            set_baseline_row(row: number): void;
            /**
             * Sets whether all columns of `grid` will have the same width.
             * @param homogeneous %TRUE to make columns homogeneous
             */
            set_column_homogeneous(homogeneous: boolean): void;
            /**
             * Sets the amount of space between columns of `grid`.
             * @param spacing the amount of space to insert between columns
             */
            set_column_spacing(spacing: number): void;
            /**
             * Sets how the baseline should be positioned on `row` of the
             * grid, in case that row is assigned more space than is requested.
             *
             * The default baseline position is %GTK_BASELINE_POSITION_CENTER.
             * @param row a row index
             * @param pos a `GtkBaselinePosition`
             */
            set_row_baseline_position(row: number, pos: BaselinePosition | null): void;
            /**
             * Sets whether all rows of `grid` will have the same height.
             * @param homogeneous %TRUE to make rows homogeneous
             */
            set_row_homogeneous(homogeneous: boolean): void;
            /**
             * Sets the amount of space between rows of `grid`.
             * @param spacing the amount of space to insert between rows
             */
            set_row_spacing(spacing: number): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GridLayout {
            // Constructor properties interface

            interface ConstructorProps extends LayoutManager.ConstructorProps {
                baseline_row: number;
                baselineRow: number;
                column_homogeneous: boolean;
                columnHomogeneous: boolean;
                column_spacing: number;
                columnSpacing: number;
                row_homogeneous: boolean;
                rowHomogeneous: boolean;
                row_spacing: number;
                rowSpacing: number;
            }
        }

        /**
         * `GtkGridLayout` is a layout manager which arranges child widgets in
         * rows and columns.
         *
         * Children have an "attach point" defined by the horizontal and vertical
         * index of the cell they occupy; children can span multiple rows or columns.
         * The layout properties for setting the attach points and spans are set
         * using the [class`Gtk`.GridLayoutChild] associated to each child widget.
         *
         * The behaviour of `GtkGridLayout` when several children occupy the same
         * grid cell is undefined.
         *
         * `GtkGridLayout` can be used like a `GtkBoxLayout` if all children are
         * attached to the same row or column; however, if you only ever need a
         * single row or column, you should consider using `GtkBoxLayout`.
         */
        class GridLayout extends LayoutManager {
            static $gtype: GObject.GType<GridLayout>;

            // Properties

            /**
             * The row to align to the baseline, when `GtkWidget:valign` is set
             * to %GTK_ALIGN_BASELINE.
             */
            get baseline_row(): number;
            set baseline_row(val: number);
            /**
             * The row to align to the baseline, when `GtkWidget:valign` is set
             * to %GTK_ALIGN_BASELINE.
             */
            get baselineRow(): number;
            set baselineRow(val: number);
            /**
             * Whether all the columns in the grid have the same width.
             */
            get column_homogeneous(): boolean;
            set column_homogeneous(val: boolean);
            /**
             * Whether all the columns in the grid have the same width.
             */
            get columnHomogeneous(): boolean;
            set columnHomogeneous(val: boolean);
            /**
             * The amount of space between to consecutive columns.
             */
            get column_spacing(): number;
            set column_spacing(val: number);
            /**
             * The amount of space between to consecutive columns.
             */
            get columnSpacing(): number;
            set columnSpacing(val: number);
            /**
             * Whether all the rows in the grid have the same height.
             */
            get row_homogeneous(): boolean;
            set row_homogeneous(val: boolean);
            /**
             * Whether all the rows in the grid have the same height.
             */
            get rowHomogeneous(): boolean;
            set rowHomogeneous(val: boolean);
            /**
             * The amount of space between to consecutive rows.
             */
            get row_spacing(): number;
            set row_spacing(val: number);
            /**
             * The amount of space between to consecutive rows.
             */
            get rowSpacing(): number;
            set rowSpacing(val: number);

            // Constructors

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

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

            static ['new'](): GridLayout;

            // Methods

            /**
             * Retrieves the row set with gtk_grid_layout_set_baseline_row().
             * @returns the global baseline row
             */
            get_baseline_row(): number;
            /**
             * Checks whether all columns of `grid` should have the same width.
             * @returns %TRUE if the columns are homogeneous, and %FALSE otherwise
             */
            get_column_homogeneous(): boolean;
            /**
             * Retrieves the spacing set with gtk_grid_layout_set_column_spacing().
             * @returns the spacing between consecutive columns
             */
            get_column_spacing(): number;
            /**
             * Returns the baseline position of `row`.
             *
             * If no value has been set with
             * [method`Gtk`.GridLayout.set_row_baseline_position],
             * the default value of %GTK_BASELINE_POSITION_CENTER
             * is returned.
             * @param row a row index
             * @returns the baseline position of @row
             */
            get_row_baseline_position(row: number): BaselinePosition;
            /**
             * Checks whether all rows of `grid` should have the same height.
             * @returns %TRUE if the rows are homogeneous, and %FALSE otherwise
             */
            get_row_homogeneous(): boolean;
            /**
             * Retrieves the spacing set with gtk_grid_layout_set_row_spacing().
             * @returns the spacing between consecutive rows
             */
            get_row_spacing(): number;
            /**
             * Sets which row defines the global baseline for the entire grid.
             *
             * Each row in the grid can have its own local baseline, but only
             * one of those is global, meaning it will be the baseline in the
             * parent of the `grid`.
             * @param row the row index
             */
            set_baseline_row(row: number): void;
            /**
             * Sets whether all columns of `grid` should have the same width.
             * @param homogeneous %TRUE to make columns homogeneous
             */
            set_column_homogeneous(homogeneous: boolean): void;
            /**
             * Sets the amount of space to insert between consecutive columns.
             * @param spacing the amount of space between columns, in pixels
             */
            set_column_spacing(spacing: number): void;
            /**
             * Sets how the baseline should be positioned on `row` of the
             * grid, in case that row is assigned more space than is requested.
             * @param row a row index
             * @param pos a `GtkBaselinePosition`
             */
            set_row_baseline_position(row: number, pos: BaselinePosition | null): void;
            /**
             * Sets whether all rows of `grid` should have the same height.
             * @param homogeneous %TRUE to make rows homogeneous
             */
            set_row_homogeneous(homogeneous: boolean): void;
            /**
             * Sets the amount of space to insert between consecutive rows.
             * @param spacing the amount of space between rows, in pixels
             */
            set_row_spacing(spacing: number): void;
        }

        namespace GridLayoutChild {
            // Constructor properties interface

            interface ConstructorProps extends LayoutChild.ConstructorProps {
                column: number;
                column_span: number;
                columnSpan: number;
                row: number;
                row_span: number;
                rowSpan: number;
            }
        }

        /**
         * `GtkLayoutChild` subclass for children in a `GtkGridLayout`.
         */
        class GridLayoutChild extends LayoutChild {
            static $gtype: GObject.GType<GridLayoutChild>;

            // Properties

            /**
             * The column to place the child in.
             */
            get column(): number;
            set column(val: number);
            /**
             * The number of columns the child spans to.
             */
            get column_span(): number;
            set column_span(val: number);
            /**
             * The number of columns the child spans to.
             */
            get columnSpan(): number;
            set columnSpan(val: number);
            /**
             * The row to place the child in.
             */
            get row(): number;
            set row(val: number);
            /**
             * The number of rows the child spans to.
             */
            get row_span(): number;
            set row_span(val: number);
            /**
             * The number of rows the child spans to.
             */
            get rowSpan(): number;
            set rowSpan(val: number);

            // Constructors

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

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

            // Methods

            /**
             * Retrieves the column number to which `child` attaches its left side.
             * @returns the column number
             */
            get_column(): number;
            /**
             * Retrieves the number of columns that `child` spans to.
             * @returns the number of columns
             */
            get_column_span(): number;
            /**
             * Retrieves the row number to which `child` attaches its top side.
             * @returns the row number
             */
            get_row(): number;
            /**
             * Retrieves the number of rows that `child` spans to.
             * @returns the number of row
             */
            get_row_span(): number;
            /**
             * Sets the column number to attach the left side of `child`.
             * @param column the attach point for @child
             */
            set_column(column: number): void;
            /**
             * Sets the number of columns `child` spans to.
             * @param span the span of @child
             */
            set_column_span(span: number): void;
            /**
             * Sets the row to place `child` in.
             * @param row the row for @child
             */
            set_row(row: number): void;
            /**
             * Sets the number of rows `child` spans to.
             * @param span the span of @child
             */
            set_row_span(span: number): void;
        }

        namespace GridView {
            // Signal callback interfaces

            interface Activate {
                (position: number): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends ListBase.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Orientable.ConstructorProps,
                    Scrollable.ConstructorProps {
                enable_rubberband: boolean;
                enableRubberband: boolean;
                factory: ListItemFactory;
                max_columns: number;
                maxColumns: number;
                min_columns: number;
                minColumns: number;
                model: SelectionModel;
                single_click_activate: boolean;
                singleClickActivate: boolean;
                tab_behavior: ListTabBehavior;
                tabBehavior: ListTabBehavior;
            }
        }

        /**
         * `GtkGridView` presents a large dynamic grid of items.
         *
         * `GtkGridView` uses its factory to generate one child widget for each
         * visible item and shows them in a grid. The orientation of the grid view
         * determines if the grid reflows vertically or horizontally.
         *
         * `GtkGridView` allows the user to select items according to the selection
         * characteristics of the model. For models that allow multiple selected items,
         * it is possible to turn on _rubberband selection_, using
         * [property`Gtk`.GridView:enable-rubberband].
         *
         * To learn more about the list widget framework, see the
         * [overview](section-list-widget.html).
         *
         * # Actions
         *
         * `GtkGridView` defines a set of built-in actions:
         *
         * - `list.activate-item` activates the item at given position by emitting the
         *   the [signal`Gtk`.GridView::activate] signal.
         *
         * # CSS nodes
         *
         * ```
         * gridview
         * ├── child[.activatable]
         * │
         * ├── child[.activatable]
         * │
         * ┊
         * ╰── [rubberband]
         * ```
         *
         * `GtkGridView` uses a single CSS node with name `gridview`. Each child uses
         * a single CSS node with name `child`. If the [property`Gtk`.ListItem:activatable]
         * property is set, the corresponding row will have the `.activatable` style
         * class. For rubberband selection, a subnode with name `rubberband` is used.
         *
         * # Accessibility
         *
         * `GtkGridView` uses the %GTK_ACCESSIBLE_ROLE_GRID role, and the items
         * use the %GTK_ACCESSIBLE_ROLE_GRID_CELL role.
         */
        class GridView extends ListBase implements Accessible, Buildable, ConstraintTarget, Orientable, Scrollable {
            static $gtype: GObject.GType<GridView>;

            // Properties

            /**
             * Allow rubberband selection.
             */
            get enable_rubberband(): boolean;
            set enable_rubberband(val: boolean);
            /**
             * Allow rubberband selection.
             */
            get enableRubberband(): boolean;
            set enableRubberband(val: boolean);
            /**
             * Factory for populating list items.
             *
             * The factory must be for configuring [class`Gtk`.ListItem] objects.
             */
            get factory(): ListItemFactory;
            set factory(val: ListItemFactory);
            /**
             * Maximum number of columns per row.
             *
             * If this number is smaller than [property`Gtk`.GridView:min-columns],
             * that value is used instead.
             */
            get max_columns(): number;
            set max_columns(val: number);
            /**
             * Maximum number of columns per row.
             *
             * If this number is smaller than [property`Gtk`.GridView:min-columns],
             * that value is used instead.
             */
            get maxColumns(): number;
            set maxColumns(val: number);
            /**
             * Minimum number of columns per row.
             */
            get min_columns(): number;
            set min_columns(val: number);
            /**
             * Minimum number of columns per row.
             */
            get minColumns(): number;
            set minColumns(val: number);
            /**
             * Model for the items displayed.
             */
            get model(): SelectionModel;
            set model(val: SelectionModel);
            /**
             * Activate rows on single click and select them on hover.
             */
            get single_click_activate(): boolean;
            set single_click_activate(val: boolean);
            /**
             * Activate rows on single click and select them on hover.
             */
            get singleClickActivate(): boolean;
            set singleClickActivate(val: boolean);
            /**
             * Behavior of the <kbd>Tab</kbd> key
             */
            get tab_behavior(): ListTabBehavior;
            set tab_behavior(val: ListTabBehavior);
            /**
             * Behavior of the <kbd>Tab</kbd> key
             */
            get tabBehavior(): ListTabBehavior;
            set tabBehavior(val: ListTabBehavior);

            // Constructors

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

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

            static ['new'](model?: SelectionModel | null, factory?: ListItemFactory | null): GridView;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate', callback: (_source: this, position: number) => void): number;
            connect_after(signal: 'activate', callback: (_source: this, position: number) => void): number;
            emit(signal: 'activate', position: number): void;

            // Methods

            /**
             * Returns whether rows can be selected by dragging with the mouse.
             * @returns %TRUE if rubberband selection is enabled
             */
            get_enable_rubberband(): boolean;
            /**
             * Gets the factory that's currently used to populate list items.
             * @returns The factory in use
             */
            get_factory(): ListItemFactory | null;
            /**
             * Gets the maximum number of columns that the grid will use.
             * @returns The maximum number of columns
             */
            get_max_columns(): number;
            /**
             * Gets the minimum number of columns that the grid will use.
             * @returns The minimum number of columns
             */
            get_min_columns(): number;
            /**
             * Gets the model that's currently used to read the items displayed.
             * @returns The model in use
             */
            get_model(): SelectionModel | null;
            /**
             * Returns whether items will be activated on single click and
             * selected on hover.
             * @returns %TRUE if items are activated on single click
             */
            get_single_click_activate(): boolean;
            /**
             * Gets the behavior set for the <kbd>Tab</kbd> key.
             * @returns The behavior of the <kbd>Tab</kbd> key
             */
            get_tab_behavior(): ListTabBehavior;
            /**
             * Scrolls to the item at the given position and performs the actions
             * specified in `flags`.
             *
             * This function works no matter if the gridview is shown or focused.
             * If it isn't, then the changes will take effect once that happens.
             * @param pos position of the item. Must be less than the number of   items in the view.
             * @param flags actions to perform
             * @param scroll details of how to perform   the scroll operation or %NULL to scroll into view
             */
            scroll_to(pos: number, flags: ListScrollFlags | null, scroll?: ScrollInfo | null): void;
            /**
             * Sets whether selections can be changed by dragging with the mouse.
             * @param enable_rubberband %TRUE to enable rubberband selection
             */
            set_enable_rubberband(enable_rubberband: boolean): void;
            /**
             * Sets the `GtkListItemFactory` to use for populating list items.
             * @param factory the factory to use
             */
            set_factory(factory?: ListItemFactory | null): void;
            /**
             * Sets the maximum number of columns to use.
             *
             * This number must be at least 1.
             *
             * If `max_columns` is smaller than the minimum set via
             * [method`Gtk`.GridView.set_min_columns], that value is used instead.
             * @param max_columns The maximum number of columns
             */
            set_max_columns(max_columns: number): void;
            /**
             * Sets the minimum number of columns to use.
             *
             * This number must be at least 1.
             *
             * If `min_columns` is smaller than the minimum set via
             * [method`Gtk`.GridView.set_max_columns], that value is ignored.
             * @param min_columns The minimum number of columns
             */
            set_min_columns(min_columns: number): void;
            /**
             * Sets the model to use.
             *
             * This must be a [iface`Gtk`.SelectionModel].
             * @param model the model to use
             */
            set_model(model?: SelectionModel | null): void;
            /**
             * Sets whether items should be activated on single click and
             * selected on hover.
             * @param single_click_activate %TRUE to activate items on single click
             */
            set_single_click_activate(single_click_activate: boolean): void;
            /**
             * Sets the behavior of the <kbd>Tab</kbd> and <kbd>Shift</kbd>+<kbd>Tab</kbd> keys.
             * @param tab_behavior The desired tab behavior
             */
            set_tab_behavior(tab_behavior: ListTabBehavior | null): void;

            // Inherited properties
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);
            /**
             * Horizontal `GtkAdjustment` of the scrollable widget.
             *
             * This adjustment is shared between the scrollable widget and its parent.
             */
            get hadjustment(): Adjustment;
            set hadjustment(val: Adjustment);
            /**
             * Determines when horizontal scrolling should start.
             */
            get hscroll_policy(): ScrollablePolicy;
            set hscroll_policy(val: ScrollablePolicy);
            /**
             * Determines when horizontal scrolling should start.
             */
            get hscrollPolicy(): ScrollablePolicy;
            set hscrollPolicy(val: ScrollablePolicy);
            /**
             * Vertical `GtkAdjustment` of the scrollable widget.
             *
             * This adjustment is shared between the scrollable widget and its parent.
             */
            get vadjustment(): Adjustment;
            set vadjustment(val: Adjustment);
            /**
             * Determines when vertical scrolling should start.
             */
            get vscroll_policy(): ScrollablePolicy;
            set vscroll_policy(val: ScrollablePolicy);
            /**
             * Determines when vertical scrolling should start.
             */
            get vscrollPolicy(): ScrollablePolicy;
            set vscrollPolicy(val: ScrollablePolicy);

            // Inherited methods
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Returns the size of a non-scrolling border around the
             * outside of the scrollable.
             *
             * An example for this would be treeview headers. GTK can use
             * this information to display overlaid graphics, like the
             * overshoot indication, at the right position.
             * @returns %TRUE if @border has been set
             */
            get_border(): [boolean, Border];
            /**
             * Retrieves the `GtkAdjustment` used for horizontal scrolling.
             * @returns horizontal `GtkAdjustment`.
             */
            get_hadjustment(): Adjustment | null;
            /**
             * Gets the horizontal `GtkScrollablePolicy`.
             * @returns The horizontal `GtkScrollablePolicy`.
             */
            get_hscroll_policy(): ScrollablePolicy;
            /**
             * Retrieves the `GtkAdjustment` used for vertical scrolling.
             * @returns vertical `GtkAdjustment`.
             */
            get_vadjustment(): Adjustment | null;
            /**
             * Gets the vertical `GtkScrollablePolicy`.
             * @returns The vertical `GtkScrollablePolicy`.
             */
            get_vscroll_policy(): ScrollablePolicy;
            /**
             * Sets the horizontal adjustment of the `GtkScrollable`.
             * @param hadjustment a `GtkAdjustment`
             */
            set_hadjustment(hadjustment?: Adjustment | null): void;
            /**
             * Sets the `GtkScrollablePolicy`.
             *
             * The policy determines whether horizontal scrolling should start
             * below the minimum width or below the natural width.
             * @param policy the horizontal `GtkScrollablePolicy`
             */
            set_hscroll_policy(policy: ScrollablePolicy | null): void;
            /**
             * Sets the vertical adjustment of the `GtkScrollable`.
             * @param vadjustment a `GtkAdjustment`
             */
            set_vadjustment(vadjustment?: Adjustment | null): void;
            /**
             * Sets the `GtkScrollablePolicy`.
             *
             * The policy determines whether vertical scrolling should start
             * below the minimum height or below the natural height.
             * @param policy the vertical `GtkScrollablePolicy`
             */
            set_vscroll_policy(policy: ScrollablePolicy | null): void;
            /**
             * Returns the size of a non-scrolling border around the
             * outside of the scrollable.
             *
             * An example for this would be treeview headers. GTK can use
             * this information to display overlaid graphics, like the
             * overshoot indication, at the right position.
             */
            vfunc_get_border(): [boolean, Border];
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace HeaderBar {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                decoration_layout: string;
                decorationLayout: string;
                show_title_buttons: boolean;
                showTitleButtons: boolean;
                title_widget: Widget;
                titleWidget: Widget;
            }
        }

        /**
         * `GtkHeaderBar` is a widget for creating custom title bars for windows.
         *
         * ![An example GtkHeaderBar](headerbar.png)
         *
         * `GtkHeaderBar` is similar to a horizontal `GtkCenterBox`. It allows
         * children to be placed at the start or the end. In addition, it allows
         * the window title to be displayed. The title will be centered with respect
         * to the width of the box, even if the children at either side take up
         * different amounts of space.
         *
         * `GtkHeaderBar` can add typical window frame controls, such as minimize,
         * maximize and close buttons, or the window icon.
         *
         * For these reasons, `GtkHeaderBar` is the natural choice for use as the
         * custom titlebar widget of a `GtkWindow` (see [method`Gtk`.Window.set_titlebar]),
         * as it gives features typical of titlebars while allowing the addition of
         * child widgets.
         *
         * ## GtkHeaderBar as GtkBuildable
         *
         * The `GtkHeaderBar` implementation of the `GtkBuildable` interface supports
         * adding children at the start or end sides by specifying “start” or “end” as
         * the “type” attribute of a `<child>` element, or setting the title widget by
         * specifying “title” value.
         *
         * By default the `GtkHeaderBar` uses a `GtkLabel` displaying the title of the
         * window it is contained in as the title widget, equivalent to the following
         * UI definition:
         *
         * ```xml
         * <object class="GtkHeaderBar">
         *   <property name="title-widget">
         *     <object class="GtkLabel">
         *       <property name="label" translatable="yes">Label</property>
         *       <property name="single-line-mode">True</property>
         *       <property name="ellipsize">end</property>
         *       <property name="width-chars">5</property>
         *       <style>
         *         <class name="title"/>
         *       </style>
         *     </object>
         *   </property>
         * </object>
         * ```
         *
         * # CSS nodes
         *
         * ```
         * headerbar
         * ╰── windowhandle
         *     ╰── box
         *         ├── box.start
         *         │   ├── windowcontrols.start
         *         │   ╰── [other children]
         *         ├── [Title Widget]
         *         ╰── box.end
         *             ├── [other children]
         *             ╰── windowcontrols.end
         * ```
         *
         * A `GtkHeaderBar`'s CSS node is called `headerbar`. It contains a `windowhandle`
         * subnode, which contains a `box` subnode, which contains two `box` subnodes at
         * the start and end of the header bar, as well as a center node that represents
         * the title.
         *
         * Each of the boxes contains a `windowcontrols` subnode, see
         * [class`Gtk`.WindowControls] for details, as well as other children.
         *
         * # Accessibility
         *
         * `GtkHeaderBar` uses the %GTK_ACCESSIBLE_ROLE_GROUP role.
         */
        class HeaderBar extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<HeaderBar>;

            // Properties

            /**
             * The decoration layout for buttons.
             *
             * If this property is not set, the
             * [property`Gtk`.Settings:gtk-decoration-layout] setting is used.
             */
            get decoration_layout(): string;
            set decoration_layout(val: string);
            /**
             * The decoration layout for buttons.
             *
             * If this property is not set, the
             * [property`Gtk`.Settings:gtk-decoration-layout] setting is used.
             */
            get decorationLayout(): string;
            set decorationLayout(val: string);
            /**
             * Whether to show title buttons like close, minimize, maximize.
             *
             * Which buttons are actually shown and where is determined
             * by the [property`Gtk`.HeaderBar:decoration-layout] property,
             * and by the state of the window (e.g. a close button will not
             * be shown if the window can't be closed).
             */
            get show_title_buttons(): boolean;
            set show_title_buttons(val: boolean);
            /**
             * Whether to show title buttons like close, minimize, maximize.
             *
             * Which buttons are actually shown and where is determined
             * by the [property`Gtk`.HeaderBar:decoration-layout] property,
             * and by the state of the window (e.g. a close button will not
             * be shown if the window can't be closed).
             */
            get showTitleButtons(): boolean;
            set showTitleButtons(val: boolean);
            /**
             * The title widget to display.
             */
            get title_widget(): Widget;
            set title_widget(val: Widget);
            /**
             * The title widget to display.
             */
            get titleWidget(): Widget;
            set titleWidget(val: Widget);

            // Constructors

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

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

            static ['new'](): HeaderBar;

            // Methods

            /**
             * Gets the decoration layout of the `GtkHeaderBar`.
             * @returns the decoration layout
             */
            get_decoration_layout(): string | null;
            /**
             * Returns whether this header bar shows the standard window
             * title buttons.
             * @returns %TRUE if title buttons are shown
             */
            get_show_title_buttons(): boolean;
            /**
             * Retrieves the title widget of the header.
             *
             * See [method`Gtk`.HeaderBar.set_title_widget].
             * @returns the title widget of the header
             */
            get_title_widget(): Widget | null;
            /**
             * Adds `child` to `bar,` packed with reference to the
             * end of the `bar`.
             * @param child the `GtkWidget` to be added to @bar
             */
            pack_end(child: Widget): void;
            /**
             * Adds `child` to `bar,` packed with reference to the
             * start of the `bar`.
             * @param child the `GtkWidget` to be added to @bar
             */
            pack_start(child: Widget): void;
            /**
             * Removes a child from the `GtkHeaderBar`.
             *
             * The child must have been added with
             * [method`Gtk`.HeaderBar.pack_start],
             * [method`Gtk`.HeaderBar.pack_end] or
             * [method`Gtk`.HeaderBar.set_title_widget].
             * @param child the child to remove
             */
            remove(child: Widget): void;
            /**
             * Sets the decoration layout for this header bar.
             *
             * This property overrides the
             * [property`Gtk`.Settings:gtk-decoration-layout] setting.
             *
             * There can be valid reasons for overriding the setting, such
             * as a header bar design that does not allow for buttons to take
             * room on the right, or only offers room for a single close button.
             * Split header bars are another example for overriding the setting.
             *
             * The format of the string is button names, separated by commas.
             * A colon separates the buttons that should appear on the left
             * from those on the right. Recognized button names are minimize,
             * maximize, close and icon (the window icon).
             *
             * For example, “icon:minimize,maximize,close” specifies an icon
             * on the left, and minimize, maximize and close buttons on the right.
             * @param layout a decoration layout, or %NULL to unset the layout
             */
            set_decoration_layout(layout?: string | null): void;
            /**
             * Sets whether this header bar shows the standard window
             * title buttons.
             * @param setting %TRUE to show standard title buttons
             */
            set_show_title_buttons(setting: boolean): void;
            /**
             * Sets the title for the `GtkHeaderBar`.
             *
             * When set to %NULL, the headerbar will display the title of
             * the window it is contained in.
             *
             * The title should help a user identify the current view.
             * To achieve the same style as the builtin title, use the
             * “title” style class.
             *
             * You should set the title widget to %NULL, for the window
             * title label to be visible again.
             * @param title_widget a widget to use for a title
             */
            set_title_widget(title_widget?: Widget | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace IMContext {
            // Signal callback interfaces

            interface Commit {
                (str: string): void;
            }

            interface DeleteSurrounding {
                (offset: number, n_chars: number): boolean;
            }

            interface PreeditChanged {
                (): void;
            }

            interface PreeditEnd {
                (): void;
            }

            interface PreeditStart {
                (): void;
            }

            interface RetrieveSurrounding {
                (): boolean;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                input_hints: InputHints;
                inputHints: InputHints;
                input_purpose: InputPurpose;
                inputPurpose: InputPurpose;
            }
        }

        /**
         * `GtkIMContext` defines the interface for GTK input methods.
         *
         * `GtkIMContext` is used by GTK text input widgets like `GtkText`
         * to map from key events to Unicode character strings.
         *
         * An input method may consume multiple key events in sequence before finally
         * outputting the composed result. This is called *preediting*, and an input
         * method may provide feedback about this process by displaying the intermediate
         * composition states as preedit text. To do so, the `GtkIMContext` will emit
         * [signal`Gtk`.IMContext::preedit-start], [signal`Gtk`.IMContext::preedit-changed]
         * and [signal`Gtk`.IMContext::preedit-end] signals.
         *
         * For instance, the built-in GTK input method [class`Gtk`.IMContextSimple]
         * implements the input of arbitrary Unicode code points by holding down the
         * <kbd>Control</kbd> and <kbd>Shift</kbd> keys and then typing <kbd>u</kbd>
         * followed by the hexadecimal digits of the code point. When releasing the
         * <kbd>Control</kbd> and <kbd>Shift</kbd> keys, preediting ends and the
         * character is inserted as text. For example,
         *
         *     Ctrl+Shift+u 2 0 A C
         *
         * results in the € sign.
         *
         * Additional input methods can be made available for use by GTK widgets as
         * loadable modules. An input method module is a small shared library which
         * provides a `GIOExtension` for the extension point named "gtk-im-module".
         *
         * To connect a widget to the users preferred input method, you should use
         * [class`Gtk`.IMMulticontext].
         */
        abstract class IMContext extends GObject.Object {
            static $gtype: GObject.GType<IMContext>;

            // Properties

            /**
             * Additional hints that allow input methods to fine-tune
             * their behaviour.
             */
            get input_hints(): InputHints;
            set input_hints(val: InputHints);
            /**
             * Additional hints that allow input methods to fine-tune
             * their behaviour.
             */
            get inputHints(): InputHints;
            set inputHints(val: InputHints);
            /**
             * The purpose of the text field that the `GtkIMContext is connected to.
             *
             * This property can be used by on-screen keyboards and other input
             * methods to adjust their behaviour.
             */
            get input_purpose(): InputPurpose;
            set input_purpose(val: InputPurpose);
            /**
             * The purpose of the text field that the `GtkIMContext is connected to.
             *
             * This property can be used by on-screen keyboards and other input
             * methods to adjust their behaviour.
             */
            get inputPurpose(): InputPurpose;
            set inputPurpose(val: InputPurpose);

            // Constructors

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

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

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'commit', callback: (_source: this, str: string) => void): number;
            connect_after(signal: 'commit', callback: (_source: this, str: string) => void): number;
            emit(signal: 'commit', str: string): void;
            connect(
                signal: 'delete-surrounding',
                callback: (_source: this, offset: number, n_chars: number) => boolean,
            ): number;
            connect_after(
                signal: 'delete-surrounding',
                callback: (_source: this, offset: number, n_chars: number) => boolean,
            ): number;
            emit(signal: 'delete-surrounding', offset: number, n_chars: number): void;
            connect(signal: 'preedit-changed', callback: (_source: this) => void): number;
            connect_after(signal: 'preedit-changed', callback: (_source: this) => void): number;
            emit(signal: 'preedit-changed'): void;
            connect(signal: 'preedit-end', callback: (_source: this) => void): number;
            connect_after(signal: 'preedit-end', callback: (_source: this) => void): number;
            emit(signal: 'preedit-end'): void;
            connect(signal: 'preedit-start', callback: (_source: this) => void): number;
            connect_after(signal: 'preedit-start', callback: (_source: this) => void): number;
            emit(signal: 'preedit-start'): void;
            connect(signal: 'retrieve-surrounding', callback: (_source: this) => boolean): number;
            connect_after(signal: 'retrieve-surrounding', callback: (_source: this) => boolean): number;
            emit(signal: 'retrieve-surrounding'): void;

            // Virtual methods

            vfunc_activate_osk(): void;
            vfunc_activate_osk_with_event(event: Gdk.Event): boolean;
            /**
             * Default handler of the [signal`Gtk`.IMContext::commit] signal.
             * @param str
             */
            vfunc_commit(str: string): void;
            /**
             * Asks the widget that the input context is attached to delete
             * characters around the cursor position by emitting the
             * `::delete_surrounding` signal.
             *
             * Note that `offset` and `n_chars` are in characters not in bytes
             * which differs from the usage other places in `GtkIMContext`.
             *
             * In order to use this function, you should first call
             * [method`Gtk`.IMContext.get_surrounding] to get the current context,
             * and call this function immediately afterwards to make sure that you
             * know what you are deleting. You should also account for the fact
             * that even if the signal was handled, the input context might not
             * have deleted all the characters that were requested to be deleted.
             *
             * This function is used by an input method that wants to make
             * substitutions in the existing text in response to new input.
             * It is not useful for applications.
             * @param offset offset from cursor position in chars;    a negative value means start before the cursor.
             * @param n_chars number of characters to delete.
             */
            vfunc_delete_surrounding(offset: number, n_chars: number): boolean;
            /**
             * Allow an input method to internally handle key press and release
             * events.
             *
             * If this function returns %TRUE, then no further processing
             * should be done for this key event.
             * @param event the key event
             */
            vfunc_filter_keypress(event: Gdk.Event): boolean;
            /**
             * Notify the input method that the widget to which this
             * input context corresponds has gained focus.
             *
             * The input method may, for example, change the displayed
             * feedback to reflect this change.
             */
            vfunc_focus_in(): void;
            /**
             * Notify the input method that the widget to which this
             * input context corresponds has lost focus.
             *
             * The input method may, for example, change the displayed
             * feedback or reset the contexts state to reflect this change.
             */
            vfunc_focus_out(): void;
            /**
             * Retrieve the current preedit string for the input context,
             * and a list of attributes to apply to the string.
             *
             * This string should be displayed inserted at the insertion point.
             */
            vfunc_get_preedit_string(): [string, Pango.AttrList, number];
            /**
             * Retrieves context around the insertion point.
             *
             * Input methods typically want context in order to constrain input text
             * based on existing text; this is important for languages such as Thai
             * where only some sequences of characters are allowed.
             *
             * This function is implemented by emitting the
             * [signal`Gtk`.IMContext::retrieve-surrounding] signal on the input method;
             * in response to this signal, a widget should provide as much context as
             * is available, up to an entire paragraph, by calling
             * [method`Gtk`.IMContext.set_surrounding].
             *
             * Note that there is no obligation for a widget to respond to the
             * `::retrieve-surrounding` signal, so input methods must be prepared to
             * function without context.
             */
            vfunc_get_surrounding(): [boolean, string, number];
            /**
             * Retrieves context around the insertion point.
             *
             * Input methods typically want context in order to constrain input
             * text based on existing text; this is important for languages such
             * as Thai where only some sequences of characters are allowed.
             *
             * This function is implemented by emitting the
             * [signal`Gtk`.IMContext::retrieve-surrounding] signal on the input method;
             * in response to this signal, a widget should provide as much context as
             * is available, up to an entire paragraph, by calling
             * [method`Gtk`.IMContext.set_surrounding_with_selection].
             *
             * Note that there is no obligation for a widget to respond to the
             * `::retrieve-surrounding` signal, so input methods must be prepared to
             * function without context.
             */
            vfunc_get_surrounding_with_selection(): [boolean, string, number, number];
            /**
             * Default handler of the [signal`Gtk`.IMContext::preedit-changed]
             *   signal.
             */
            vfunc_preedit_changed(): void;
            /**
             * Default handler of the [signal`Gtk`.IMContext::preedit-end] signal.
             */
            vfunc_preedit_end(): void;
            /**
             * Default handler of the [signal`Gtk`.IMContext::preedit-start] signal.
             */
            vfunc_preedit_start(): void;
            /**
             * Notify the input method that a change such as a change in cursor
             * position has been made.
             *
             * This will typically cause the input method to clear the preedit state.
             */
            vfunc_reset(): void;
            /**
             * Default handler of the
             *   [signal`Gtk`.IMContext::retrieve-surrounding] signal.
             */
            vfunc_retrieve_surrounding(): boolean;
            /**
             * Set the client widget for the input context.
             *
             * This is the `GtkWidget` holding the input focus. This widget is
             * used in order to correctly position status windows, and may
             * also be used for purposes internal to the input method.
             * @param widget the client widget. This may be %NULL to indicate   that the previous client widget no longer exists.
             */
            vfunc_set_client_widget(widget?: Widget | null): void;
            /**
             * Notify the input method that a change in cursor
             * position has been made.
             *
             * The location is relative to the client widget.
             * @param area new location
             */
            vfunc_set_cursor_location(area: Gdk.Rectangle): void;
            /**
             * Sets surrounding context around the insertion point and preedit
             * string.
             *
             * This function is expected to be called in response to the
             * [signal`Gtk`.IMContext::retrieve-surrounding] signal, and will
             * likely have no effect if called at other times.
             * @param text text surrounding the insertion point, as UTF-8.   the preedit string should not be included within @text
             * @param len the length of @text, or -1 if @text is nul-terminated
             * @param cursor_index the byte index of the insertion cursor within @text.
             */
            vfunc_set_surrounding(text: string, len: number, cursor_index: number): void;
            /**
             * Sets surrounding context around the insertion point and preedit
             * string. This function is expected to be called in response to the
             * [signal`Gtk`.IMContext::retrieve_surrounding] signal, and will likely
             * have no effect if called at other times.
             * @param text text surrounding the insertion point, as UTF-8.   the preedit string should not be included within @text
             * @param len the length of @text, or -1 if @text is nul-terminated
             * @param cursor_index the byte index of the insertion cursor within @text
             * @param anchor_index the byte index of the selection bound within @text
             */
            vfunc_set_surrounding_with_selection(
                text: string,
                len: number,
                cursor_index: number,
                anchor_index: number,
            ): void;
            /**
             * Sets whether the IM context should use the preedit string
             * to display feedback.
             *
             * If `use_preedit` is %FALSE (default is %TRUE), then the IM context
             * may use some other method to display feedback, such as displaying
             * it in a child of the root window.
             * @param use_preedit whether the IM context should use the preedit string.
             */
            vfunc_set_use_preedit(use_preedit: boolean): void;

            // Methods

            /**
             * Requests the platform to show an on-screen keyboard for user input.
             *
             * This method will return %TRUE if this request was actually performed
             * to the platform, other environmental factors may result in an on-screen
             * keyboard effectively not showing up.
             * @param event a [class@Gdk.Event]
             * @returns %TRUE if an on-screen keyboard could be requested to the platform.
             */
            activate_osk(event?: Gdk.Event | null): boolean;
            /**
             * Asks the widget that the input context is attached to delete
             * characters around the cursor position by emitting the
             * `::delete_surrounding` signal.
             *
             * Note that `offset` and `n_chars` are in characters not in bytes
             * which differs from the usage other places in `GtkIMContext`.
             *
             * In order to use this function, you should first call
             * [method`Gtk`.IMContext.get_surrounding] to get the current context,
             * and call this function immediately afterwards to make sure that you
             * know what you are deleting. You should also account for the fact
             * that even if the signal was handled, the input context might not
             * have deleted all the characters that were requested to be deleted.
             *
             * This function is used by an input method that wants to make
             * substitutions in the existing text in response to new input.
             * It is not useful for applications.
             * @param offset offset from cursor position in chars;    a negative value means start before the cursor.
             * @param n_chars number of characters to delete.
             * @returns %TRUE if the signal was handled.
             */
            delete_surrounding(offset: number, n_chars: number): boolean;
            /**
             * Allow an input method to forward key press and release events
             * to another input method without necessarily having a `GdkEvent`
             * available.
             * @param press whether to forward a key press or release event
             * @param surface the surface the event is for
             * @param device the device that the event is for
             * @param time the timestamp for the event
             * @param keycode the keycode for the event
             * @param state modifier state for the event
             * @param group the active keyboard group for the event
             * @returns %TRUE if the input method handled the key event.
             */
            filter_key(
                press: boolean,
                surface: Gdk.Surface,
                device: Gdk.Device,
                time: number,
                keycode: number,
                state: Gdk.ModifierType | null,
                group: number,
            ): boolean;
            /**
             * Allow an input method to internally handle key press and release
             * events.
             *
             * If this function returns %TRUE, then no further processing
             * should be done for this key event.
             * @param event the key event
             * @returns %TRUE if the input method handled the key event.
             */
            filter_keypress(event: Gdk.Event): boolean;
            /**
             * Notify the input method that the widget to which this
             * input context corresponds has gained focus.
             *
             * The input method may, for example, change the displayed
             * feedback to reflect this change.
             */
            focus_in(): void;
            /**
             * Notify the input method that the widget to which this
             * input context corresponds has lost focus.
             *
             * The input method may, for example, change the displayed
             * feedback or reset the contexts state to reflect this change.
             */
            focus_out(): void;
            /**
             * Retrieve the current preedit string for the input context,
             * and a list of attributes to apply to the string.
             *
             * This string should be displayed inserted at the insertion point.
             */
            get_preedit_string(): [string, Pango.AttrList, number];
            /**
             * Retrieves context around the insertion point.
             *
             * Input methods typically want context in order to constrain input text
             * based on existing text; this is important for languages such as Thai
             * where only some sequences of characters are allowed.
             *
             * This function is implemented by emitting the
             * [signal`Gtk`.IMContext::retrieve-surrounding] signal on the input method;
             * in response to this signal, a widget should provide as much context as
             * is available, up to an entire paragraph, by calling
             * [method`Gtk`.IMContext.set_surrounding].
             *
             * Note that there is no obligation for a widget to respond to the
             * `::retrieve-surrounding` signal, so input methods must be prepared to
             * function without context.
             * @returns `TRUE` if surrounding text was provided; in this case    you must free the result stored in `text`.
             */
            get_surrounding(): [boolean, string, number];
            /**
             * Retrieves context around the insertion point.
             *
             * Input methods typically want context in order to constrain input
             * text based on existing text; this is important for languages such
             * as Thai where only some sequences of characters are allowed.
             *
             * This function is implemented by emitting the
             * [signal`Gtk`.IMContext::retrieve-surrounding] signal on the input method;
             * in response to this signal, a widget should provide as much context as
             * is available, up to an entire paragraph, by calling
             * [method`Gtk`.IMContext.set_surrounding_with_selection].
             *
             * Note that there is no obligation for a widget to respond to the
             * `::retrieve-surrounding` signal, so input methods must be prepared to
             * function without context.
             * @returns `TRUE` if surrounding text was provided; in this case   you must free the result stored in `text`.
             */
            get_surrounding_with_selection(): [boolean, string, number, number];
            /**
             * Notify the input method that a change such as a change in cursor
             * position has been made.
             *
             * This will typically cause the input method to clear the preedit state.
             */
            reset(): void;
            /**
             * Set the client widget for the input context.
             *
             * This is the `GtkWidget` holding the input focus. This widget is
             * used in order to correctly position status windows, and may
             * also be used for purposes internal to the input method.
             * @param widget the client widget. This may be %NULL to indicate   that the previous client widget no longer exists.
             */
            set_client_widget(widget?: Widget | null): void;
            /**
             * Notify the input method that a change in cursor
             * position has been made.
             *
             * The location is relative to the client widget.
             * @param area new location
             */
            set_cursor_location(area: Gdk.Rectangle): void;
            /**
             * Sets surrounding context around the insertion point and preedit
             * string.
             *
             * This function is expected to be called in response to the
             * [signal`Gtk`.IMContext::retrieve-surrounding] signal, and will
             * likely have no effect if called at other times.
             * @param text text surrounding the insertion point, as UTF-8.   the preedit string should not be included within @text
             * @param len the length of @text, or -1 if @text is nul-terminated
             * @param cursor_index the byte index of the insertion cursor within @text.
             */
            set_surrounding(text: string, len: number, cursor_index: number): void;
            /**
             * Sets surrounding context around the insertion point and preedit
             * string. This function is expected to be called in response to the
             * [signal`Gtk`.IMContext::retrieve_surrounding] signal, and will likely
             * have no effect if called at other times.
             * @param text text surrounding the insertion point, as UTF-8.   the preedit string should not be included within @text
             * @param len the length of @text, or -1 if @text is nul-terminated
             * @param cursor_index the byte index of the insertion cursor within @text
             * @param anchor_index the byte index of the selection bound within @text
             */
            set_surrounding_with_selection(text: string, len: number, cursor_index: number, anchor_index: number): void;
            /**
             * Sets whether the IM context should use the preedit string
             * to display feedback.
             *
             * If `use_preedit` is %FALSE (default is %TRUE), then the IM context
             * may use some other method to display feedback, such as displaying
             * it in a child of the root window.
             * @param use_preedit whether the IM context should use the preedit string.
             */
            set_use_preedit(use_preedit: boolean): void;
        }

        namespace IMContextSimple {
            // Constructor properties interface

            interface ConstructorProps extends IMContext.ConstructorProps {}
        }

        /**
         * `GtkIMContextSimple` is an input method supporting table-based input methods.
         *
         * ## Compose sequences
         *
         * `GtkIMContextSimple` reads compose sequences from the first of the
         * following files that is found: ~/.config/gtk-4.0/Compose, ~/.XCompose,
         * /usr/share/X11/locale/$locale/Compose (for locales that have a nontrivial
         * Compose file). A subset of the file syntax described in the Compose(5)
         * manual page is supported. Additionally, `include "%L"` loads GTK’s built-in
         * table of compose sequences rather than the locale-specific one from X11.
         *
         * If none of these files is found, `GtkIMContextSimple` uses a built-in table
         * of compose sequences that is derived from the X11 Compose files.
         *
         * Note that compose sequences typically start with the Compose_key, which is
         * often not available as a dedicated key on keyboards. Keyboard layouts may
         * map this keysym to other keys, such as the right Control key.
         *
         * ## Unicode characters
         *
         * `GtkIMContextSimple` also supports numeric entry of Unicode characters
         * by typing <kbd>Ctrl</kbd>-<kbd>Shift</kbd>-<kbd>u</kbd>, followed by a
         * hexadecimal Unicode codepoint.
         *
         * For example,
         *
         *     Ctrl-Shift-u 1 2 3 Enter
         *
         * yields U+0123 LATIN SMALL LETTER G WITH CEDILLA, i.e. ģ.
         *
         * ## Dead keys
         *
         * `GtkIMContextSimple` supports dead keys. For example, typing
         *
         *     dead_acute a
         *
         *  yields U+00E! LATIN SMALL LETTER_A WITH ACUTE, i.e. á. Note that this
         *  depends on the keyboard layout including dead keys.
         */
        class IMContextSimple extends IMContext {
            static $gtype: GObject.GType<IMContextSimple>;

            // Fields

            object: IMContext;

            // Constructors

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

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

            static ['new'](): IMContextSimple;

            // Methods

            /**
             * Adds an additional table from the X11 compose file.
             * @param compose_file The path of compose file
             */
            add_compose_file(compose_file: string): void;
        }

        namespace IMMulticontext {
            // Constructor properties interface

            interface ConstructorProps extends IMContext.ConstructorProps {}
        }

        /**
         * `GtkIMMulticontext` is an input method context supporting multiple,
         * switchable input methods.
         *
         * Text widgets such as `GtkText` or `GtkTextView` use a `GtkIMMultiContext`
         * to implement their `im-module` property for switching between different
         * input methods.
         */
        class IMMulticontext extends IMContext {
            static $gtype: GObject.GType<IMMulticontext>;

            // Fields

            object: IMContext;

            // Constructors

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

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

            static ['new'](): IMMulticontext;

            // Methods

            /**
             * Gets the id of the currently active delegate of the `context`.
             * @returns the id of the currently active delegate
             */
            get_context_id(): string;
            /**
             * Sets the context id for `context`.
             *
             * This causes the currently active delegate of `context` to be
             * replaced by the delegate corresponding to the new context id.
             *
             * Setting this to a non-%NULL value overrides the system-wide
             * IM module setting. See the [property`Gtk`.Settings:gtk-im-module]
             * property.
             * @param context_id the id to use
             */
            set_context_id(context_id?: string | null): void;
        }

        namespace IconPaintable {
            // Constructor properties interface

            interface ConstructorProps
                extends GObject.Object.ConstructorProps,
                    Gdk.Paintable.ConstructorProps,
                    SymbolicPaintable.ConstructorProps {
                file: Gio.File;
                icon_name: string;
                iconName: string;
                is_symbolic: boolean;
                isSymbolic: boolean;
            }
        }

        /**
         * Contains information found when looking up an icon in `GtkIconTheme`.
         *
         * `GtkIconPaintable` implements `GdkPaintable`.
         */
        class IconPaintable extends GObject.Object implements Gdk.Paintable, SymbolicPaintable {
            static $gtype: GObject.GType<IconPaintable>;

            // Properties

            /**
             * The file representing the icon, if any.
             */
            get file(): Gio.File;
            /**
             * The icon name that was chosen during lookup.
             */
            get icon_name(): string;
            /**
             * The icon name that was chosen during lookup.
             */
            get iconName(): string;
            /**
             * Whether the icon is symbolic or not.
             */
            get is_symbolic(): boolean;
            /**
             * Whether the icon is symbolic or not.
             */
            get isSymbolic(): boolean;

            // Constructors

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

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

            static new_for_file(file: Gio.File, size: number, scale: number): IconPaintable;

            // Methods

            /**
             * Gets the `GFile` that was used to load the icon.
             *
             * Returns %NULL if the icon was not loaded from a file.
             * @returns the `GFile` for the icon
             */
            get_file(): Gio.File | null;
            /**
             * Get the icon name being used for this icon.
             *
             * When an icon looked up in the icon theme was not available, the
             * icon theme may use fallback icons - either those specified to
             * gtk_icon_theme_lookup_icon() or the always-available
             * "image-missing". The icon chosen is returned by this function.
             *
             * If the icon was created without an icon theme, this function
             * returns %NULL.
             * @returns the themed icon-name for the   icon, or %NULL if its not a themed icon.
             */
            get_icon_name(): string | null;

            // Inherited methods
            /**
             * Compute a concrete size for the `GdkPaintable`.
             *
             * Applies the sizing algorithm outlined in the
             * [CSS Image spec](https://drafts.csswg.org/css-images-3/#default-sizing)
             * to the given `paintable`. See that link for more details.
             *
             * It is not necessary to call this function when both `specified_width`
             * and `specified_height` are known, but it is useful to call this
             * function in GtkWidget:measure implementations to compute the
             * other dimension when only one dimension is given.
             * @param specified_width the width @paintable could be drawn into or   0.0 if unknown
             * @param specified_height the height @paintable could be drawn into or   0.0 if unknown
             * @param default_width the width @paintable would be drawn into if   no other constraints were given
             * @param default_height the height @paintable would be drawn into if   no other constraints were given
             */
            compute_concrete_size(
                specified_width: number,
                specified_height: number,
                default_width: number,
                default_height: number,
            ): [number, number];
            /**
             * Gets an immutable paintable for the current contents displayed by `paintable`.
             *
             * This is useful when you want to retain the current state of an animation,
             * for example to take a screenshot of a running animation.
             *
             * If the `paintable` is already immutable, it will return itself.
             * @returns An immutable paintable for the current   contents of @paintable
             */
            get_current_image(): Gdk.Paintable;
            /**
             * Get flags for the paintable.
             *
             * This is oftentimes useful for optimizations.
             *
             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
             * @returns The `GdkPaintableFlags` for this paintable
             */
            get_flags(): Gdk.PaintableFlags;
            /**
             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
             *
             * The aspect ratio is the width divided by the height, so a value of 0.5
             * means that the `paintable` prefers to be displayed twice as high as it
             * is wide. Consumers of this interface can use this to preserve aspect
             * ratio when displaying the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * Usually when a `paintable` returns nonzero values from
             * [method`Gdk`.Paintable.get_intrinsic_width] and
             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
             * should conform to those values, though that is not required.
             *
             * If the `paintable` does not have a preferred aspect ratio,
             * it returns 0. Negative values are never returned.
             * @returns the intrinsic aspect ratio of @paintable or 0 if none.
             */
            get_intrinsic_aspect_ratio(): number;
            /**
             * Gets the preferred height the `paintable` would like to be displayed at.
             *
             * Consumers of this interface can use this to reserve enough space to draw
             * the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * If the `paintable` does not have a preferred height, it returns 0.
             * Negative values are never returned.
             * @returns the intrinsic height of @paintable or 0 if none.
             */
            get_intrinsic_height(): number;
            /**
             * Gets the preferred width the `paintable` would like to be displayed at.
             *
             * Consumers of this interface can use this to reserve enough space to draw
             * the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * If the `paintable` does not have a preferred width, it returns 0.
             * Negative values are never returned.
             * @returns the intrinsic width of @paintable or 0 if none.
             */
            get_intrinsic_width(): number;
            /**
             * Called by implementations of `GdkPaintable` to invalidate their contents.
             *
             * Unless the contents are invalidated, implementations must guarantee that
             * multiple calls of [method`Gdk`.Paintable.snapshot] produce the same output.
             *
             * This function will emit the [signal`Gdk`.Paintable::invalidate-contents]
             * signal.
             *
             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_CONTENTS flag,
             * it must not call this function.
             */
            invalidate_contents(): void;
            /**
             * Called by implementations of `GdkPaintable` to invalidate their size.
             *
             * As long as the size is not invalidated, `paintable` must return the same
             * values for its intrinsic width, height and aspect ratio.
             *
             * This function will emit the [signal`Gdk`.Paintable::invalidate-size]
             * signal.
             *
             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_SIZE flag,
             * it must not call this function.
             */
            invalidate_size(): void;
            /**
             * Snapshots the given paintable with the given `width` and `height`.
             *
             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
             * If `width` and `height` are not larger than zero, this function will
             * do nothing.
             * @param snapshot a `GdkSnapshot` to snapshot to
             * @param width width to snapshot in
             * @param height height to snapshot in
             */
            snapshot(snapshot: Gdk.Snapshot, width: number, height: number): void;
            /**
             * Gets an immutable paintable for the current contents displayed by `paintable`.
             *
             * This is useful when you want to retain the current state of an animation,
             * for example to take a screenshot of a running animation.
             *
             * If the `paintable` is already immutable, it will return itself.
             */
            vfunc_get_current_image(): Gdk.Paintable;
            /**
             * Get flags for the paintable.
             *
             * This is oftentimes useful for optimizations.
             *
             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
             */
            vfunc_get_flags(): Gdk.PaintableFlags;
            /**
             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
             *
             * The aspect ratio is the width divided by the height, so a value of 0.5
             * means that the `paintable` prefers to be displayed twice as high as it
             * is wide. Consumers of this interface can use this to preserve aspect
             * ratio when displaying the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * Usually when a `paintable` returns nonzero values from
             * [method`Gdk`.Paintable.get_intrinsic_width] and
             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
             * should conform to those values, though that is not required.
             *
             * If the `paintable` does not have a preferred aspect ratio,
             * it returns 0. Negative values are never returned.
             */
            vfunc_get_intrinsic_aspect_ratio(): number;
            /**
             * Gets the preferred height the `paintable` would like to be displayed at.
             *
             * Consumers of this interface can use this to reserve enough space to draw
             * the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * If the `paintable` does not have a preferred height, it returns 0.
             * Negative values are never returned.
             */
            vfunc_get_intrinsic_height(): number;
            /**
             * Gets the preferred width the `paintable` would like to be displayed at.
             *
             * Consumers of this interface can use this to reserve enough space to draw
             * the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * If the `paintable` does not have a preferred width, it returns 0.
             * Negative values are never returned.
             */
            vfunc_get_intrinsic_width(): number;
            /**
             * Snapshots the given paintable with the given `width` and `height`.
             *
             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
             * If `width` and `height` are not larger than zero, this function will
             * do nothing.
             * @param snapshot a `GdkSnapshot` to snapshot to
             * @param width width to snapshot in
             * @param height height to snapshot in
             */
            vfunc_snapshot(snapshot: Gdk.Snapshot, width: number, height: number): void;
            /**
             * Snapshots the paintable with the given colors.
             *
             * If less than 4 colors are provided, GTK will pad the array with default
             * colors.
             * @param snapshot a `GdkSnapshot` to snapshot to
             * @param width width to snapshot in
             * @param height height to snapshot in
             * @param colors a pointer to an array of colors
             */
            snapshot_symbolic(snapshot: Gdk.Snapshot, width: number, height: number, colors: Gdk.RGBA[]): void;
            /**
             * Snapshots the paintable with the given colors.
             *
             * If less than 4 colors are provided, GTK will pad the array with default
             * colors.
             * @param snapshot a `GdkSnapshot` to snapshot to
             * @param width width to snapshot in
             * @param height height to snapshot in
             * @param colors a pointer to an array of colors
             */
            vfunc_snapshot_symbolic(snapshot: Gdk.Snapshot, width: number, height: number, colors: Gdk.RGBA[]): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace IconTheme {
            // Signal callback interfaces

            interface Changed {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                display: Gdk.Display;
                icon_names: string[];
                iconNames: string[];
                resource_path: string[];
                resourcePath: string[];
                search_path: string[];
                searchPath: string[];
                theme_name: string;
                themeName: string;
            }
        }

        /**
         * `GtkIconTheme` provides a facility for loading themed icons.
         *
         * The main reason for using a name rather than simply providing a filename
         * is to allow different icons to be used depending on what “icon theme” is
         * selected by the user. The operation of icon themes on Linux and Unix
         * follows the [Icon Theme Specification](http://www.freedesktop.org/Standards/icon-theme-spec)
         * There is a fallback icon theme, named `hicolor`, where applications
         * should install their icons, but additional icon themes can be installed
         * as operating system vendors and users choose.
         *
         * In many cases, named themes are used indirectly, via [class`Gtk`.Image]
         * rather than directly, but looking up icons directly is also simple. The
         * `GtkIconTheme` object acts as a database of all the icons in the current
         * theme. You can create new `GtkIconTheme` objects, but it’s much more
         * efficient to use the standard icon theme of the `GtkWidget` so that the
         * icon information is shared with other people looking up icons.
         *
         * ```c
         * GtkIconTheme *icon_theme;
         * GtkIconPaintable *icon;
         * GdkPaintable *paintable;
         *
         * icon_theme = gtk_icon_theme_get_for_display (gtk_widget_get_display (my_widget));
         * icon = gtk_icon_theme_lookup_icon (icon_theme,
         *                                    "my-icon-name", // icon name
         *                                    48, // icon size
         *                                    1,  // scale
         *                                    0,  // flags);
         * paintable = GDK_PAINTABLE (icon);
         * // Use the paintable
         * g_object_unref (icon);
         * ```
         */
        class IconTheme extends GObject.Object {
            static $gtype: GObject.GType<IconTheme>;

            // Properties

            /**
             * The display that this icon theme object is attached to.
             */
            get display(): Gdk.Display;
            set display(val: Gdk.Display);
            /**
             * The icon names that are supported by the icon theme.
             */
            get icon_names(): string[];
            /**
             * The icon names that are supported by the icon theme.
             */
            get iconNames(): string[];
            /**
             * Resource paths that will be looked at when looking for icons,
             * similar to search paths.
             *
             * The resources are considered as part of the hicolor icon theme
             * and must be located in subdirectories that are defined in the
             * hicolor icon theme, such as ``path/`16x16/actions/run.png`.
             * Icons that are directly placed in the resource path instead
             * of a subdirectory are also considered as ultimate fallback.
             */
            get resource_path(): string[];
            set resource_path(val: string[]);
            /**
             * Resource paths that will be looked at when looking for icons,
             * similar to search paths.
             *
             * The resources are considered as part of the hicolor icon theme
             * and must be located in subdirectories that are defined in the
             * hicolor icon theme, such as ``path/`16x16/actions/run.png`.
             * Icons that are directly placed in the resource path instead
             * of a subdirectory are also considered as ultimate fallback.
             */
            get resourcePath(): string[];
            set resourcePath(val: string[]);
            /**
             * The search path for this icon theme.
             *
             * When looking for icons, GTK will search for a subdirectory of
             * one or more of the directories in the search path with the same
             * name as the icon theme containing an index.theme file. (Themes
             * from multiple of the path elements are combined to allow themes
             * to be extended by adding icons in the user’s home directory.)
             */
            get search_path(): string[];
            set search_path(val: string[]);
            /**
             * The search path for this icon theme.
             *
             * When looking for icons, GTK will search for a subdirectory of
             * one or more of the directories in the search path with the same
             * name as the icon theme containing an index.theme file. (Themes
             * from multiple of the path elements are combined to allow themes
             * to be extended by adding icons in the user’s home directory.)
             */
            get searchPath(): string[];
            set searchPath(val: string[]);
            /**
             * The name of the icon theme that is being used.
             *
             * Unless set to a different value, this will be the value of
             * the `GtkSettings:gtk-icon-theme-name` property of the `GtkSettings`
             * object associated to the display of the icontheme object.
             */
            get theme_name(): string;
            set theme_name(val: string);
            /**
             * The name of the icon theme that is being used.
             *
             * Unless set to a different value, this will be the value of
             * the `GtkSettings:gtk-icon-theme-name` property of the `GtkSettings`
             * object associated to the display of the icontheme object.
             */
            get themeName(): string;
            set themeName(val: string);

            // Constructors

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

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

            static ['new'](): IconTheme;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'changed', callback: (_source: this) => void): number;
            connect_after(signal: 'changed', callback: (_source: this) => void): number;
            emit(signal: 'changed'): void;

            // Static methods

            /**
             * Gets the icon theme object associated with `display`.
             *
             * If this function has not previously been called for the given
             * display, a new icon theme object will be created and associated
             * with the display. Icon theme objects are fairly expensive to create,
             * so using this function is usually a better choice than calling
             * [ctor`Gtk`.IconTheme.new] and setting the display yourself; by using
             * this function a single icon theme object will be shared between users.
             * @param display a `GdkDisplay`
             */
            static get_for_display(display: Gdk.Display): IconTheme;

            // Methods

            /**
             * Adds a resource path that will be looked at when looking
             * for icons, similar to search paths.
             *
             * See [method`Gtk`.IconTheme.set_resource_path].
             *
             * This function should be used to make application-specific icons
             * available as part of the icon theme.
             * @param path a resource path
             */
            add_resource_path(path: string): void;
            /**
             * Appends a directory to the search path.
             *
             * See [method`Gtk`.IconTheme.set_search_path].
             * @param path directory name to append to the icon path
             */
            add_search_path(path: string): void;
            /**
             * Returns the display that the `GtkIconTheme` object was
             * created for.
             * @returns the display of @icon_theme
             */
            get_display(): Gdk.Display | null;
            /**
             * Lists the names of icons in the current icon theme.
             * @returns a string array   holding the names of all the icons in the theme. You must   free the array using g_strfreev().
             */
            get_icon_names(): string[];
            /**
             * Returns an array of integers describing the sizes at which
             * the icon is available without scaling.
             *
             * A size of -1 means that the icon is available in a scalable
             * format. The array is zero-terminated.
             * @param icon_name the name of an icon
             * @returns A newly   allocated array describing the sizes at which the icon is   available. The array should be freed with g_free() when it is no   longer needed.
             */
            get_icon_sizes(icon_name: string): number[];
            /**
             * Gets the current resource path.
             *
             * See [method`Gtk`.IconTheme.set_resource_path].
             * @returns A list of resource paths
             */
            get_resource_path(): string[] | null;
            /**
             * Gets the current search path.
             *
             * See [method`Gtk`.IconTheme.set_search_path].
             * @returns a list of icon theme path directories
             */
            get_search_path(): string[] | null;
            /**
             * Gets the current icon theme name.
             * @returns the current icon theme name,
             */
            get_theme_name(): string;
            /**
             * Checks whether an icon theme includes an icon
             * for a particular `GIcon`.
             * @param gicon a `GIcon`
             * @returns %TRUE if @self includes an icon for @gicon
             */
            has_gicon(gicon: Gio.Icon): boolean;
            /**
             * Checks whether an icon theme includes an icon
             * for a particular name.
             * @param icon_name the name of an icon
             * @returns %TRUE if @self includes an  icon for @icon_name.
             */
            has_icon(icon_name: string): boolean;
            /**
             * Looks up a icon for a desired size and window scale.
             *
             * The icon can then be rendered by using it as a `GdkPaintable`,
             * or you can get information such as the filename and size.
             * @param icon the `GIcon` to look up
             * @param size desired icon size, in application pixels
             * @param scale the desired scale
             * @param direction text direction the icon will be displayed in
             * @param flags flags modifying the behavior of the icon lookup
             * @returns a `GtkIconPaintable` containing   information about the icon. Unref with g_object_unref()
             */
            lookup_by_gicon(
                icon: Gio.Icon,
                size: number,
                scale: number,
                direction: TextDirection | null,
                flags: IconLookupFlags | null,
            ): IconPaintable;
            /**
             * Looks up a named icon for a desired size and window scale,
             * returning a `GtkIconPaintable`.
             *
             * The icon can then be rendered by using it as a `GdkPaintable`,
             * or you can get information such as the filename and size.
             *
             * If the available `icon_name` is not available and `fallbacks` are
             * provided, they will be tried in order.
             *
             * If no matching icon is found, then a paintable that renders the
             * "missing icon" icon is returned. If you need to do something else
             * for missing icons you need to use [method`Gtk`.IconTheme.has_icon].
             *
             * Note that you probably want to listen for icon theme changes and
             * update the icon. This is usually done by overriding the
             * GtkWidgetClass.css-changed() function.
             * @param icon_name the name of the icon to lookup
             * @param fallbacks fallback names
             * @param size desired icon size, in application pixels
             * @param scale the window scale this will be displayed on
             * @param direction text direction the icon will be displayed in
             * @param flags flags modifying the behavior of the icon lookup
             * @returns a `GtkIconPaintable` object   containing the icon.
             */
            lookup_icon(
                icon_name: string,
                fallbacks: string[] | null,
                size: number,
                scale: number,
                direction: TextDirection | null,
                flags: IconLookupFlags | null,
            ): IconPaintable;
            /**
             * Sets the resource paths that will be looked at when
             * looking for icons, similar to search paths.
             *
             * The resources are considered as part of the hicolor icon theme
             * and must be located in subdirectories that are defined in the
             * hicolor icon theme, such as ``path/`16x16/actions/run.png`
             * or ``path/`scalable/actions/run.svg`.
             *
             * Icons that are directly placed in the resource path instead
             * of a subdirectory are also considered as ultimate fallback,
             * but they are treated like unthemed icons.
             * @param path NULL-terminated array of resource paths   that are searched for icons
             */
            set_resource_path(path?: string[] | null): void;
            /**
             * Sets the search path for the icon theme object.
             *
             * When looking for an icon theme, GTK will search for a subdirectory
             * of one or more of the directories in `path` with the same name
             * as the icon theme containing an index.theme file. (Themes from
             * multiple of the path elements are combined to allow themes to be
             * extended by adding icons in the user’s home directory.)
             *
             * In addition if an icon found isn’t found either in the current
             * icon theme or the default icon theme, and an image file with
             * the right name is found directly in one of the elements of
             * `path,` then that image will be used for the icon name.
             * (This is legacy feature, and new icons should be put
             * into the fallback icon theme, which is called hicolor,
             * rather than directly on the icon path.)
             * @param path NULL-terminated   array of directories that are searched for icon themes
             */
            set_search_path(path?: string[] | null): void;
            /**
             * Sets the name of the icon theme that the `GtkIconTheme` object uses
             * overriding system configuration.
             *
             * This function cannot be called on the icon theme objects returned
             * from [func`Gtk`.IconTheme.get_for_display].
             * @param theme_name name of icon theme to use instead of   configured theme, or %NULL to unset a previously set custom theme
             */
            set_theme_name(theme_name?: string | null): void;
        }

        namespace IconView {
            // Signal callback interfaces

            interface ActivateCursorItem {
                (): boolean;
            }

            interface ItemActivated {
                (path: TreePath): void;
            }

            interface MoveCursor {
                (step: MovementStep, count: number, extend: boolean, modify: boolean): boolean;
            }

            interface SelectAll {
                (): void;
            }

            interface SelectCursorItem {
                (): void;
            }

            interface SelectionChanged {
                (): void;
            }

            interface ToggleCursorItem {
                (): void;
            }

            interface UnselectAll {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    CellLayout.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Scrollable.ConstructorProps {
                activate_on_single_click: boolean;
                activateOnSingleClick: boolean;
                cell_area: CellArea;
                cellArea: CellArea;
                column_spacing: number;
                columnSpacing: number;
                columns: number;
                item_orientation: Orientation;
                itemOrientation: Orientation;
                item_padding: number;
                itemPadding: number;
                item_width: number;
                itemWidth: number;
                margin: number;
                markup_column: number;
                markupColumn: number;
                model: TreeModel;
                pixbuf_column: number;
                pixbufColumn: number;
                reorderable: boolean;
                row_spacing: number;
                rowSpacing: number;
                selection_mode: SelectionMode;
                selectionMode: SelectionMode;
                spacing: number;
                text_column: number;
                textColumn: number;
                tooltip_column: number;
                tooltipColumn: number;
            }
        }

        /**
         * `GtkIconView` is a widget which displays data in a grid of icons.
         *
         * `GtkIconView` provides an alternative view on a `GtkTreeModel`.
         * It displays the model as a grid of icons with labels. Like
         * [class`Gtk`.TreeView], it allows to select one or multiple items
         * (depending on the selection mode, see [method`Gtk`.IconView.set_selection_mode]).
         * In addition to selection with the arrow keys, `GtkIconView` supports
         * rubberband selection, which is controlled by dragging the pointer.
         *
         * Note that if the tree model is backed by an actual tree store (as
         * opposed to a flat list where the mapping to icons is obvious),
         * `GtkIconView` will only display the first level of the tree and
         * ignore the tree’s branches.
         *
         * ## CSS nodes
         *
         * ```
         * iconview.view
         * ╰── [rubberband]
         * ```
         *
         * `GtkIconView` has a single CSS node with name iconview and style class .view.
         * For rubberband selection, a subnode with name rubberband is used.
         */
        class IconView extends Widget implements Accessible, Buildable, CellLayout, ConstraintTarget, Scrollable {
            static $gtype: GObject.GType<IconView>;

            // Properties

            /**
             * The activate-on-single-click property specifies whether the "item-activated" signal
             * will be emitted after a single click.
             */
            get activate_on_single_click(): boolean;
            set activate_on_single_click(val: boolean);
            /**
             * The activate-on-single-click property specifies whether the "item-activated" signal
             * will be emitted after a single click.
             */
            get activateOnSingleClick(): boolean;
            set activateOnSingleClick(val: boolean);
            /**
             * The `GtkCellArea` used to layout cell renderers for this view.
             *
             * If no area is specified when creating the icon view with gtk_icon_view_new_with_area()
             * a `GtkCellAreaBox` will be used.
             */
            get cell_area(): CellArea;
            /**
             * The `GtkCellArea` used to layout cell renderers for this view.
             *
             * If no area is specified when creating the icon view with gtk_icon_view_new_with_area()
             * a `GtkCellAreaBox` will be used.
             */
            get cellArea(): CellArea;
            /**
             * The column-spacing property specifies the space which is inserted between
             * the columns of the icon view.
             */
            get column_spacing(): number;
            set column_spacing(val: number);
            /**
             * The column-spacing property specifies the space which is inserted between
             * the columns of the icon view.
             */
            get columnSpacing(): number;
            set columnSpacing(val: number);
            /**
             * The columns property contains the number of the columns in which the
             * items should be displayed. If it is -1, the number of columns will
             * be chosen automatically to fill the available area.
             */
            get columns(): number;
            set columns(val: number);
            /**
             * The item-orientation property specifies how the cells (i.e. the icon and
             * the text) of the item are positioned relative to each other.
             */
            get item_orientation(): Orientation;
            set item_orientation(val: Orientation);
            /**
             * The item-orientation property specifies how the cells (i.e. the icon and
             * the text) of the item are positioned relative to each other.
             */
            get itemOrientation(): Orientation;
            set itemOrientation(val: Orientation);
            /**
             * The item-padding property specifies the padding around each
             * of the icon view's item.
             */
            get item_padding(): number;
            set item_padding(val: number);
            /**
             * The item-padding property specifies the padding around each
             * of the icon view's item.
             */
            get itemPadding(): number;
            set itemPadding(val: number);
            /**
             * The item-width property specifies the width to use for each item.
             * If it is set to -1, the icon view will automatically determine a
             * suitable item size.
             */
            get item_width(): number;
            set item_width(val: number);
            /**
             * The item-width property specifies the width to use for each item.
             * If it is set to -1, the icon view will automatically determine a
             * suitable item size.
             */
            get itemWidth(): number;
            set itemWidth(val: number);
            /**
             * The margin property specifies the space which is inserted
             * at the edges of the icon view.
             */
            get margin(): number;
            set margin(val: number);
            /**
             * The ::markup-column property contains the number of the model column
             * containing markup information to be displayed. The markup column must be
             * of type `G_TYPE_STRING`. If this property and the :text-column property
             * are both set to column numbers, it overrides the text column.
             * If both are set to -1, no texts are displayed.
             */
            get markup_column(): number;
            set markup_column(val: number);
            /**
             * The ::markup-column property contains the number of the model column
             * containing markup information to be displayed. The markup column must be
             * of type `G_TYPE_STRING`. If this property and the :text-column property
             * are both set to column numbers, it overrides the text column.
             * If both are set to -1, no texts are displayed.
             */
            get markupColumn(): number;
            set markupColumn(val: number);
            /**
             * The model of the icon view.
             */
            get model(): TreeModel;
            set model(val: TreeModel);
            /**
             * The ::pixbuf-column property contains the number of the model column
             * containing the pixbufs which are displayed. The pixbuf column must be
             * of type `GDK_TYPE_PIXBUF`. Setting this property to -1 turns off the
             * display of pixbufs.
             */
            get pixbuf_column(): number;
            set pixbuf_column(val: number);
            /**
             * The ::pixbuf-column property contains the number of the model column
             * containing the pixbufs which are displayed. The pixbuf column must be
             * of type `GDK_TYPE_PIXBUF`. Setting this property to -1 turns off the
             * display of pixbufs.
             */
            get pixbufColumn(): number;
            set pixbufColumn(val: number);
            /**
             * The reorderable property specifies if the items can be reordered
             * by DND.
             */
            get reorderable(): boolean;
            set reorderable(val: boolean);
            /**
             * The row-spacing property specifies the space which is inserted between
             * the rows of the icon view.
             */
            get row_spacing(): number;
            set row_spacing(val: number);
            /**
             * The row-spacing property specifies the space which is inserted between
             * the rows of the icon view.
             */
            get rowSpacing(): number;
            set rowSpacing(val: number);
            /**
             * The ::selection-mode property specifies the selection mode of
             * icon view. If the mode is %GTK_SELECTION_MULTIPLE, rubberband selection
             * is enabled, for the other modes, only keyboard selection is possible.
             */
            get selection_mode(): SelectionMode;
            set selection_mode(val: SelectionMode);
            /**
             * The ::selection-mode property specifies the selection mode of
             * icon view. If the mode is %GTK_SELECTION_MULTIPLE, rubberband selection
             * is enabled, for the other modes, only keyboard selection is possible.
             */
            get selectionMode(): SelectionMode;
            set selectionMode(val: SelectionMode);
            /**
             * The spacing property specifies the space which is inserted between
             * the cells (i.e. the icon and the text) of an item.
             */
            get spacing(): number;
            set spacing(val: number);
            /**
             * The ::text-column property contains the number of the model column
             * containing the texts which are displayed. The text column must be
             * of type `G_TYPE_STRING`. If this property and the :markup-column
             * property are both set to -1, no texts are displayed.
             */
            get text_column(): number;
            set text_column(val: number);
            /**
             * The ::text-column property contains the number of the model column
             * containing the texts which are displayed. The text column must be
             * of type `G_TYPE_STRING`. If this property and the :markup-column
             * property are both set to -1, no texts are displayed.
             */
            get textColumn(): number;
            set textColumn(val: number);
            /**
             * The column of the icon view model which is being used for displaying
             * tooltips on it's rows.
             */
            get tooltip_column(): number;
            set tooltip_column(val: number);
            /**
             * The column of the icon view model which is being used for displaying
             * tooltips on it's rows.
             */
            get tooltipColumn(): number;
            set tooltipColumn(val: number);

            // Constructors

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

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

            static ['new'](): IconView;

            static new_with_area(area: CellArea): IconView;

            static new_with_model(model: TreeModel): IconView;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate-cursor-item', callback: (_source: this) => boolean): number;
            connect_after(signal: 'activate-cursor-item', callback: (_source: this) => boolean): number;
            emit(signal: 'activate-cursor-item'): void;
            connect(signal: 'item-activated', callback: (_source: this, path: TreePath) => void): number;
            connect_after(signal: 'item-activated', callback: (_source: this, path: TreePath) => void): number;
            emit(signal: 'item-activated', path: TreePath): void;
            connect(
                signal: 'move-cursor',
                callback: (
                    _source: this,
                    step: MovementStep,
                    count: number,
                    extend: boolean,
                    modify: boolean,
                ) => boolean,
            ): number;
            connect_after(
                signal: 'move-cursor',
                callback: (
                    _source: this,
                    step: MovementStep,
                    count: number,
                    extend: boolean,
                    modify: boolean,
                ) => boolean,
            ): number;
            emit(signal: 'move-cursor', step: MovementStep, count: number, extend: boolean, modify: boolean): void;
            connect(signal: 'select-all', callback: (_source: this) => void): number;
            connect_after(signal: 'select-all', callback: (_source: this) => void): number;
            emit(signal: 'select-all'): void;
            connect(signal: 'select-cursor-item', callback: (_source: this) => void): number;
            connect_after(signal: 'select-cursor-item', callback: (_source: this) => void): number;
            emit(signal: 'select-cursor-item'): void;
            connect(signal: 'selection-changed', callback: (_source: this) => void): number;
            connect_after(signal: 'selection-changed', callback: (_source: this) => void): number;
            emit(signal: 'selection-changed'): void;
            connect(signal: 'toggle-cursor-item', callback: (_source: this) => void): number;
            connect_after(signal: 'toggle-cursor-item', callback: (_source: this) => void): number;
            emit(signal: 'toggle-cursor-item'): void;
            connect(signal: 'unselect-all', callback: (_source: this) => void): number;
            connect_after(signal: 'unselect-all', callback: (_source: this) => void): number;
            emit(signal: 'unselect-all'): void;

            // Methods

            /**
             * Creates a `GdkPaintable` representation of the item at `path`.
             * This image is used for a drag icon.
             * @param path a `GtkTreePath` in @icon_view
             * @returns a newly-allocated `GdkPaintable` of the drag icon.
             */
            create_drag_icon(path: TreePath): Gdk.Paintable | null;
            /**
             * Turns `icon_view` into a drop destination for automatic DND. Calling this
             * method sets `GtkIconView`:reorderable to %FALSE.
             * @param formats the formats that the drag will support
             * @param actions the bitmask of possible actions for a drag to this    widget
             */
            enable_model_drag_dest(formats: Gdk.ContentFormats, actions: Gdk.DragAction | null): void;
            /**
             * Turns `icon_view` into a drag source for automatic DND. Calling this
             * method sets `GtkIconView`:reorderable to %FALSE.
             * @param start_button_mask Mask of allowed buttons to start drag
             * @param formats the formats that the drag will support
             * @param actions the bitmask of possible actions for a drag from this    widget
             */
            enable_model_drag_source(
                start_button_mask: Gdk.ModifierType | null,
                formats: Gdk.ContentFormats,
                actions: Gdk.DragAction | null,
            ): void;
            /**
             * Gets the setting set by gtk_icon_view_set_activate_on_single_click().
             * @returns %TRUE if item-activated will be emitted on a single click
             */
            get_activate_on_single_click(): boolean;
            /**
             * Fills the bounding rectangle in widget coordinates for the cell specified by
             * `path` and `cell`. If `cell` is %NULL the main cell area is used.
             *
             * This function is only valid if `icon_view` is realized.
             * @param path a `GtkTreePath`
             * @param cell a `GtkCellRenderer`
             * @returns %FALSE if there is no such item, %TRUE otherwise
             */
            get_cell_rect(path: TreePath, cell: CellRenderer | null): [boolean, Gdk.Rectangle];
            /**
             * Returns the value of the ::column-spacing property.
             * @returns the space between columns
             */
            get_column_spacing(): number;
            /**
             * Returns the value of the ::columns property.
             * @returns the number of columns, or -1
             */
            get_columns(): number;
            /**
             * Fills in `path` and `cell` with the current cursor path and cell.
             * If the cursor isn’t currently set, then *`path` will be %NULL.
             * If no cell currently has focus, then *`cell` will be %NULL.
             *
             * The returned `GtkTreePath` must be freed with gtk_tree_path_free().
             * @returns %TRUE if the cursor is set.
             */
            get_cursor(): [boolean, TreePath | null, CellRenderer | null];
            // Conflicted with Gtk.Widget.get_cursor
            get_cursor(...args: never[]): any;
            /**
             * Determines the destination item for a given position.
             * @param drag_x the position to determine the destination item for
             * @param drag_y the position to determine the destination item for
             * @returns whether there is an item at the given position.
             */
            get_dest_item_at_pos(
                drag_x: number,
                drag_y: number,
            ): [boolean, TreePath | null, IconViewDropPosition | null];
            /**
             * Gets information about the item that is highlighted for feedback.
             */
            get_drag_dest_item(): [TreePath | null, IconViewDropPosition | null];
            /**
             * Gets the path and cell for the icon at the given position.
             * @param x The x position to be identified
             * @param y The y position to be identified
             * @returns %TRUE if an item exists at the specified position
             */
            get_item_at_pos(x: number, y: number): [boolean, TreePath | null, CellRenderer | null];
            /**
             * Gets the column in which the item `path` is currently
             * displayed. Column numbers start at 0.
             * @param path the `GtkTreePath` of the item
             * @returns The column in which the item is displayed
             */
            get_item_column(path: TreePath): number;
            /**
             * Returns the value of the ::item-orientation property which determines
             * whether the labels are drawn beside the icons instead of below.
             * @returns the relative position of texts and icons
             */
            get_item_orientation(): Orientation;
            /**
             * Returns the value of the ::item-padding property.
             * @returns the padding around items
             */
            get_item_padding(): number;
            /**
             * Gets the row in which the item `path` is currently
             * displayed. Row numbers start at 0.
             * @param path the `GtkTreePath` of the item
             * @returns The row in which the item is displayed
             */
            get_item_row(path: TreePath): number;
            /**
             * Returns the value of the ::item-width property.
             * @returns the width of a single item, or -1
             */
            get_item_width(): number;
            /**
             * Returns the value of the ::margin property.
             * @returns the space at the borders
             */
            get_margin(): number;
            /**
             * Returns the column with markup text for `icon_view`.
             * @returns the markup column, or -1 if it’s unset.
             */
            get_markup_column(): number;
            /**
             * Returns the model the `GtkIconView` is based on.  Returns %NULL if the
             * model is unset.
             * @returns The currently used `GtkTreeModel`
             */
            get_model(): TreeModel | null;
            /**
             * Gets the path for the icon at the given position.
             * @param x The x position to be identified
             * @param y The y position to be identified
             * @returns The `GtkTreePath` corresponding to the icon or %NULL if no icon exists at that position.
             */
            get_path_at_pos(x: number, y: number): TreePath | null;
            /**
             * Returns the column with pixbufs for `icon_view`.
             * @returns the pixbuf column, or -1 if it’s unset.
             */
            get_pixbuf_column(): number;
            /**
             * Retrieves whether the user can reorder the list via drag-and-drop.
             * See gtk_icon_view_set_reorderable().
             * @returns %TRUE if the list can be reordered.
             */
            get_reorderable(): boolean;
            /**
             * Returns the value of the ::row-spacing property.
             * @returns the space between rows
             */
            get_row_spacing(): number;
            /**
             * Creates a list of paths of all selected items. Additionally, if you are
             * planning on modifying the model after calling this function, you may
             * want to convert the returned list into a list of `GtkTreeRowReferences`.
             * To do this, you can use gtk_tree_row_reference_new().
             *
             * To free the return value, use `g_list_free_full`:
             *
             * ```c
             * GtkWidget *icon_view = gtk_icon_view_new ();
             * // Use icon_view
             *
             * GList *list = gtk_icon_view_get_selected_items (GTK_ICON_VIEW (icon_view));
             *
             * // use list
             *
             * g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
             * ```
             *
             * @returns A `GList` containing a `GtkTreePath` for each selected row.
             */
            get_selected_items(): TreePath[];
            /**
             * Gets the selection mode of the `icon_view`.
             * @returns the current selection mode
             */
            get_selection_mode(): SelectionMode;
            /**
             * Returns the value of the ::spacing property.
             * @returns the space between cells
             */
            get_spacing(): number;
            /**
             * Returns the column with text for `icon_view`.
             * @returns the text column, or -1 if it’s unset.
             */
            get_text_column(): number;
            /**
             * Returns the column of `icon_view’`s model which is being used for
             * displaying tooltips on `icon_view’`s rows.
             * @returns the index of the tooltip column that is currently being used, or -1 if this is disabled.
             */
            get_tooltip_column(): number;
            /**
             * This function is supposed to be used in a `GtkWidget::query-tooltip`
             * signal handler for `GtkIconView`. The `x,` `y` and `keyboard_tip` values
             * which are received in the signal handler, should be passed to this
             * function without modification.
             *
             * The return value indicates whether there is an icon view item at the given
             * coordinates (%TRUE) or not (%FALSE) for mouse tooltips. For keyboard
             * tooltips the item returned will be the cursor item. When %TRUE, then any of
             * `model,` `path` and `iter` which have been provided will be set to point to
             * that row and the corresponding model.
             * @param x the x coordinate (relative to widget coordinates)
             * @param y the y coordinate (relative to widget coordinates)
             * @param keyboard_tip whether this is a keyboard tooltip or not
             * @returns whether or not the given tooltip context points to an item
             */
            get_tooltip_context(
                x: number,
                y: number,
                keyboard_tip: boolean,
            ): [boolean, TreeModel | null, TreePath | null, TreeIter | null];
            /**
             * Sets `start_path` and `end_path` to be the first and last visible path.
             * Note that there may be invisible paths in between.
             *
             * Both paths should be freed with gtk_tree_path_free() after use.
             * @returns %TRUE, if valid paths were placed in @start_path and @end_path
             */
            get_visible_range(): [boolean, TreePath | null, TreePath | null];
            /**
             * Activates the item determined by `path`.
             * @param path The `GtkTreePath` to be activated
             */
            item_activated(path: TreePath): void;
            /**
             * Returns %TRUE if the icon pointed to by `path` is currently
             * selected. If `path` does not point to a valid location, %FALSE is returned.
             * @param path A `GtkTreePath` to check selection on.
             * @returns %TRUE if @path is selected.
             */
            path_is_selected(path: TreePath): boolean;
            /**
             * Moves the alignments of `icon_view` to the position specified by `path`.
             * `row_align` determines where the row is placed, and `col_align` determines
             * where `column` is placed.  Both are expected to be between 0.0 and 1.0.
             * 0.0 means left/top alignment, 1.0 means right/bottom alignment, 0.5 means
             * center.
             *
             * If `use_align` is %FALSE, then the alignment arguments are ignored, and the
             * tree does the minimum amount of work to scroll the item onto the screen.
             * This means that the item will be scrolled to the edge closest to its current
             * position.  If the item is currently visible on the screen, nothing is done.
             *
             * This function only works if the model is set, and `path` is a valid row on
             * the model. If the model changes before the `icon_view` is realized, the
             * centered path will be modified to reflect this change.
             * @param path The path of the item to move to.
             * @param use_align whether to use alignment arguments, or %FALSE.
             * @param row_align The vertical alignment of the item specified by @path.
             * @param col_align The horizontal alignment of the item specified by @path.
             */
            scroll_to_path(path: TreePath, use_align: boolean, row_align: number, col_align: number): void;
            /**
             * Selects all the icons. `icon_view` must has its selection mode set
             * to %GTK_SELECTION_MULTIPLE.
             */
            select_all(): void;
            /**
             * Selects the row at `path`.
             * @param path The `GtkTreePath` to be selected.
             */
            select_path(path: TreePath): void;
            /**
             * Calls a function for each selected icon. Note that the model or
             * selection cannot be modified from within this function.
             * @param func The function to call for each selected icon.
             */
            selected_foreach(func: IconViewForeachFunc): void;
            /**
             * Causes the `GtkIconView`::item-activated signal to be emitted on
             * a single click instead of a double click.
             * @param single %TRUE to emit item-activated on a single click
             */
            set_activate_on_single_click(single: boolean): void;
            /**
             * Sets the ::column-spacing property which specifies the space
             * which is inserted between the columns of the icon view.
             * @param column_spacing the column spacing
             */
            set_column_spacing(column_spacing: number): void;
            /**
             * Sets the ::columns property which determines in how
             * many columns the icons are arranged. If `columns` is
             * -1, the number of columns will be chosen automatically
             * to fill the available area.
             * @param columns the number of columns
             */
            set_columns(columns: number): void;
            /**
             * Sets the current keyboard focus to be at `path,` and selects it.  This is
             * useful when you want to focus the user’s attention on a particular item.
             * If `cell` is not %NULL, then focus is given to the cell specified by
             * it. Additionally, if `start_editing` is %TRUE, then editing should be
             * started in the specified cell.
             *
             * This function is often followed by `gtk_widget_grab_focus
             * (icon_view)` in order to give keyboard focus to the widget.
             * Please note that editing can only happen when the widget is realized.
             * @param path A `GtkTreePath`
             * @param cell One of the cell renderers of @icon_view
             * @param start_editing %TRUE if the specified cell should start being edited.
             */
            set_cursor(path: TreePath, cell: CellRenderer | null, start_editing: boolean): void;
            // Conflicted with Gtk.Widget.set_cursor
            set_cursor(...args: never[]): any;
            /**
             * Sets the item that is highlighted for feedback.
             * @param path The path of the item to highlight
             * @param pos Specifies where to drop, relative to the item
             */
            set_drag_dest_item(path: TreePath | null, pos: IconViewDropPosition | null): void;
            /**
             * Sets the ::item-orientation property which determines whether the labels
             * are drawn beside the icons instead of below.
             * @param orientation the relative position of texts and icons
             */
            set_item_orientation(orientation: Orientation | null): void;
            /**
             * Sets the `GtkIconView`:item-padding property which specifies the padding
             * around each of the icon view’s items.
             * @param item_padding the item padding
             */
            set_item_padding(item_padding: number): void;
            /**
             * Sets the ::item-width property which specifies the width
             * to use for each item. If it is set to -1, the icon view will
             * automatically determine a suitable item size.
             * @param item_width the width for each item
             */
            set_item_width(item_width: number): void;
            /**
             * Sets the ::margin property which specifies the space
             * which is inserted at the top, bottom, left and right
             * of the icon view.
             * @param margin the margin
             */
            set_margin(margin: number): void;
            /**
             * Sets the column with markup information for `icon_view` to be
             * `column`. The markup column must be of type `G_TYPE_STRING`.
             * If the markup column is set to something, it overrides
             * the text column set by gtk_icon_view_set_text_column().
             * @param column A column in the currently used model, or -1 to display no text
             */
            set_markup_column(column: number): void;
            /**
             * Sets the model for a `GtkIconView`.
             * If the `icon_view` already has a model set, it will remove
             * it before setting the new model.  If `model` is %NULL, then
             * it will unset the old model.
             * @param model The model.
             */
            set_model(model?: TreeModel | null): void;
            /**
             * Sets the column with pixbufs for `icon_view` to be `column`. The pixbuf
             * column must be of type `GDK_TYPE_PIXBUF`
             * @param column A column in the currently used model, or -1 to disable
             */
            set_pixbuf_column(column: number): void;
            /**
             * This function is a convenience function to allow you to reorder models that
             * support the `GtkTreeDragSourceIface` and the `GtkTreeDragDestIface`. Both
             * `GtkTreeStore` and `GtkListStore` support these. If `reorderable` is %TRUE, then
             * the user can reorder the model by dragging and dropping rows.  The
             * developer can listen to these changes by connecting to the model's
             * row_inserted and row_deleted signals. The reordering is implemented by setting up
             * the icon view as a drag source and destination. Therefore, drag and
             * drop can not be used in a reorderable view for any other purpose.
             *
             * This function does not give you any degree of control over the order -- any
             * reordering is allowed.  If more control is needed, you should probably
             * handle drag and drop manually.
             * @param reorderable %TRUE, if the list of items can be reordered.
             */
            set_reorderable(reorderable: boolean): void;
            /**
             * Sets the ::row-spacing property which specifies the space
             * which is inserted between the rows of the icon view.
             * @param row_spacing the row spacing
             */
            set_row_spacing(row_spacing: number): void;
            /**
             * Sets the selection mode of the `icon_view`.
             * @param mode The selection mode
             */
            set_selection_mode(mode: SelectionMode | null): void;
            /**
             * Sets the ::spacing property which specifies the space
             * which is inserted between the cells (i.e. the icon and
             * the text) of an item.
             * @param spacing the spacing
             */
            set_spacing(spacing: number): void;
            /**
             * Sets the column with text for `icon_view` to be `column`. The text
             * column must be of type `G_TYPE_STRING`.
             * @param column A column in the currently used model, or -1 to display no text
             */
            set_text_column(column: number): void;
            /**
             * Sets the tip area of `tooltip` to the area which `cell` occupies in
             * the item pointed to by `path`. See also gtk_tooltip_set_tip_area().
             *
             * See also gtk_icon_view_set_tooltip_column() for a simpler alternative.
             * @param tooltip a `GtkTooltip`
             * @param path a `GtkTreePath`
             * @param cell a `GtkCellRenderer`
             */
            set_tooltip_cell(tooltip: Tooltip, path: TreePath, cell?: CellRenderer | null): void;
            /**
             * If you only plan to have simple (text-only) tooltips on full items, you
             * can use this function to have `GtkIconView` handle these automatically
             * for you. `column` should be set to the column in `icon_view’`s model
             * containing the tooltip texts, or -1 to disable this feature.
             *
             * When enabled, `GtkWidget:has-tooltip` will be set to %TRUE and
             * `icon_view` will connect a `GtkWidget::query-tooltip` signal handler.
             *
             * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
             * so &, <, etc have to be escaped in the text.
             * @param column an integer, which is a valid column number for @icon_view’s model
             */
            set_tooltip_column(column: number): void;
            /**
             * Sets the tip area of `tooltip` to be the area covered by the item at `path`.
             * See also gtk_icon_view_set_tooltip_column() for a simpler alternative.
             * See also gtk_tooltip_set_tip_area().
             * @param tooltip a `GtkTooltip`
             * @param path a `GtkTreePath`
             */
            set_tooltip_item(tooltip: Tooltip, path: TreePath): void;
            /**
             * Unselects all the icons.
             */
            unselect_all(): void;
            /**
             * Unselects the row at `path`.
             * @param path The `GtkTreePath` to be unselected.
             */
            unselect_path(path: TreePath): void;
            /**
             * Undoes the effect of gtk_icon_view_enable_model_drag_dest(). Calling this
             * method sets `GtkIconView`:reorderable to %FALSE.
             */
            unset_model_drag_dest(): void;
            /**
             * Undoes the effect of gtk_icon_view_enable_model_drag_source(). Calling this
             * method sets `GtkIconView`:reorderable to %FALSE.
             */
            unset_model_drag_source(): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * Horizontal `GtkAdjustment` of the scrollable widget.
             *
             * This adjustment is shared between the scrollable widget and its parent.
             */
            get hadjustment(): Adjustment;
            set hadjustment(val: Adjustment);
            /**
             * Determines when horizontal scrolling should start.
             */
            get hscroll_policy(): ScrollablePolicy;
            set hscroll_policy(val: ScrollablePolicy);
            /**
             * Determines when horizontal scrolling should start.
             */
            get hscrollPolicy(): ScrollablePolicy;
            set hscrollPolicy(val: ScrollablePolicy);
            /**
             * Vertical `GtkAdjustment` of the scrollable widget.
             *
             * This adjustment is shared between the scrollable widget and its parent.
             */
            get vadjustment(): Adjustment;
            set vadjustment(val: Adjustment);
            /**
             * Determines when vertical scrolling should start.
             */
            get vscroll_policy(): ScrollablePolicy;
            set vscroll_policy(val: ScrollablePolicy);
            /**
             * Determines when vertical scrolling should start.
             */
            get vscrollPolicy(): ScrollablePolicy;
            set vscrollPolicy(val: ScrollablePolicy);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Adds an attribute mapping to the list in `cell_layout`.
             *
             * The `column` is the column of the model to get a value from, and the
             * `attribute` is the property on `cell` to be set from that value. So for
             * example if column 2 of the model contains strings, you could have the
             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
             * In this context "attribute" and "property" are used interchangeably.
             * @param cell a `GtkCellRenderer`
             * @param attribute a property on the renderer
             * @param column the column position on the model to get the attribute from
             */
            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
            /**
             * Unsets all the mappings on all renderers on `cell_layout` and
             * removes all renderers from `cell_layout`.
             */
            clear(): void;
            /**
             * Clears all existing attributes previously set with
             * gtk_cell_layout_set_attributes().
             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
             */
            clear_attributes(cell: CellRenderer): void;
            /**
             * Returns the underlying `GtkCellArea` which might be `cell_layout`
             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
             * is used by `cell_layout`.
             * @returns the cell area used by @cell_layout
             */
            get_area(): CellArea | null;
            /**
             * Returns the cell renderers which have been added to `cell_layout`.
             * @returns a list of cell renderers. The list, but not the renderers has   been newly allocated and should be freed with g_list_free()   when no longer needed.
             */
            get_cells(): CellRenderer[];
            /**
             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
             * `cell` is allocated no more space than it needs. Any unused space is
             * divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            pack_end(cell: CellRenderer, expand: boolean): void;
            /**
             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
             * then the `cell` is allocated no more space than it needs. Any unused space
             * is divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            pack_start(cell: CellRenderer, expand: boolean): void;
            /**
             * Re-inserts `cell` at `position`.
             *
             * Note that `cell` has already to be packed into `cell_layout`
             * for this to function properly.
             * @param cell a `GtkCellRenderer` to reorder
             * @param position new position to insert @cell at
             */
            reorder(cell: CellRenderer, position: number): void;
            /**
             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
             *
             * This function is used instead of the standard attributes mapping
             * for setting the column value, and should set the value of `cell_layout’`s
             * cell renderer(s) as appropriate.
             *
             * `func` may be %NULL to remove a previously set function.
             * @param cell a `GtkCellRenderer`
             * @param func the `GtkCellLayout`DataFunc to use
             */
            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
            /**
             * Adds an attribute mapping to the list in `cell_layout`.
             *
             * The `column` is the column of the model to get a value from, and the
             * `attribute` is the property on `cell` to be set from that value. So for
             * example if column 2 of the model contains strings, you could have the
             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
             * In this context "attribute" and "property" are used interchangeably.
             * @param cell a `GtkCellRenderer`
             * @param attribute a property on the renderer
             * @param column the column position on the model to get the attribute from
             */
            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
            /**
             * Unsets all the mappings on all renderers on `cell_layout` and
             * removes all renderers from `cell_layout`.
             */
            vfunc_clear(): void;
            /**
             * Clears all existing attributes previously set with
             * gtk_cell_layout_set_attributes().
             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
             */
            vfunc_clear_attributes(cell: CellRenderer): void;
            /**
             * Returns the underlying `GtkCellArea` which might be `cell_layout`
             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
             * is used by `cell_layout`.
             */
            vfunc_get_area(): CellArea | null;
            /**
             * Returns the cell renderers which have been added to `cell_layout`.
             */
            vfunc_get_cells(): CellRenderer[];
            /**
             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
             * `cell` is allocated no more space than it needs. Any unused space is
             * divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
            /**
             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
             * then the `cell` is allocated no more space than it needs. Any unused space
             * is divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
            /**
             * Re-inserts `cell` at `position`.
             *
             * Note that `cell` has already to be packed into `cell_layout`
             * for this to function properly.
             * @param cell a `GtkCellRenderer` to reorder
             * @param position new position to insert @cell at
             */
            vfunc_reorder(cell: CellRenderer, position: number): void;
            /**
             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
             *
             * This function is used instead of the standard attributes mapping
             * for setting the column value, and should set the value of `cell_layout’`s
             * cell renderer(s) as appropriate.
             *
             * `func` may be %NULL to remove a previously set function.
             * @param cell a `GtkCellRenderer`
             * @param func the `GtkCellLayout`DataFunc to use
             */
            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
            /**
             * Returns the size of a non-scrolling border around the
             * outside of the scrollable.
             *
             * An example for this would be treeview headers. GTK can use
             * this information to display overlaid graphics, like the
             * overshoot indication, at the right position.
             * @returns %TRUE if @border has been set
             */
            get_border(): [boolean, Border];
            /**
             * Retrieves the `GtkAdjustment` used for horizontal scrolling.
             * @returns horizontal `GtkAdjustment`.
             */
            get_hadjustment(): Adjustment | null;
            /**
             * Gets the horizontal `GtkScrollablePolicy`.
             * @returns The horizontal `GtkScrollablePolicy`.
             */
            get_hscroll_policy(): ScrollablePolicy;
            /**
             * Retrieves the `GtkAdjustment` used for vertical scrolling.
             * @returns vertical `GtkAdjustment`.
             */
            get_vadjustment(): Adjustment | null;
            /**
             * Gets the vertical `GtkScrollablePolicy`.
             * @returns The vertical `GtkScrollablePolicy`.
             */
            get_vscroll_policy(): ScrollablePolicy;
            /**
             * Sets the horizontal adjustment of the `GtkScrollable`.
             * @param hadjustment a `GtkAdjustment`
             */
            set_hadjustment(hadjustment?: Adjustment | null): void;
            /**
             * Sets the `GtkScrollablePolicy`.
             *
             * The policy determines whether horizontal scrolling should start
             * below the minimum width or below the natural width.
             * @param policy the horizontal `GtkScrollablePolicy`
             */
            set_hscroll_policy(policy: ScrollablePolicy | null): void;
            /**
             * Sets the vertical adjustment of the `GtkScrollable`.
             * @param vadjustment a `GtkAdjustment`
             */
            set_vadjustment(vadjustment?: Adjustment | null): void;
            /**
             * Sets the `GtkScrollablePolicy`.
             *
             * The policy determines whether vertical scrolling should start
             * below the minimum height or below the natural height.
             * @param policy the vertical `GtkScrollablePolicy`
             */
            set_vscroll_policy(policy: ScrollablePolicy | null): void;
            /**
             * Returns the size of a non-scrolling border around the
             * outside of the scrollable.
             *
             * An example for this would be treeview headers. GTK can use
             * this information to display overlaid graphics, like the
             * overshoot indication, at the right position.
             */
            vfunc_get_border(): [boolean, Border];
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Image {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                file: string;
                gicon: Gio.Icon;
                icon_name: string;
                iconName: string;
                icon_size: IconSize;
                iconSize: IconSize;
                paintable: Gdk.Paintable;
                pixel_size: number;
                pixelSize: number;
                resource: string;
                storage_type: ImageType;
                storageType: ImageType;
                use_fallback: boolean;
                useFallback: boolean;
            }
        }

        /**
         * The `GtkImage` widget displays an image.
         *
         * ![An example GtkImage](image.png)
         *
         * Various kinds of object can be displayed as an image; most typically,
         * you would load a `GdkTexture` from a file, using the convenience function
         * [ctor`Gtk`.Image.new_from_file], for instance:
         *
         * ```c
         * GtkWidget *image = gtk_image_new_from_file ("myfile.png");
         * ```
         *
         * If the file isn’t loaded successfully, the image will contain a
         * “broken image” icon similar to that used in many web browsers.
         *
         * If you want to handle errors in loading the file yourself,
         * for example by displaying an error message, then load the image with
         * [ctor`Gdk`.Texture.new_from_file], then create the `GtkImage` with
         * [ctor`Gtk`.Image.new_from_paintable].
         *
         * Sometimes an application will want to avoid depending on external data
         * files, such as image files. See the documentation of `GResource` inside
         * GIO, for details. In this case, [property`Gtk`.Image:resource],
         * [ctor`Gtk`.Image.new_from_resource], and [method`Gtk`.Image.set_from_resource]
         * should be used.
         *
         * `GtkImage` displays its image as an icon, with a size that is determined
         * by the application. See [class`Gtk`.Picture] if you want to show an image
         * at is actual size.
         *
         * ## CSS nodes
         *
         * `GtkImage` has a single CSS node with the name `image`. The style classes
         * `.normal-icons` or `.large-icons` may appear, depending on the
         * [property`Gtk`.Image:icon-size] property.
         *
         * ## Accessibility
         *
         * `GtkImage` uses the `GTK_ACCESSIBLE_ROLE_IMG` role.
         */
        class Image extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<Image>;

            // Properties

            /**
             * A path to the file to display.
             */
            get file(): string;
            set file(val: string);
            /**
             * The `GIcon` displayed in the GtkImage.
             *
             * For themed icons, If the icon theme is changed, the image will be updated
             * automatically.
             */
            get gicon(): Gio.Icon;
            set gicon(val: Gio.Icon);
            /**
             * The name of the icon in the icon theme.
             *
             * If the icon theme is changed, the image will be updated automatically.
             */
            get icon_name(): string;
            set icon_name(val: string);
            /**
             * The name of the icon in the icon theme.
             *
             * If the icon theme is changed, the image will be updated automatically.
             */
            get iconName(): string;
            set iconName(val: string);
            /**
             * The symbolic size to display icons at.
             */
            get icon_size(): IconSize;
            set icon_size(val: IconSize);
            /**
             * The symbolic size to display icons at.
             */
            get iconSize(): IconSize;
            set iconSize(val: IconSize);
            /**
             * The `GdkPaintable` to display.
             */
            get paintable(): Gdk.Paintable;
            set paintable(val: Gdk.Paintable);
            /**
             * The size in pixels to display icons at.
             *
             * If set to a value != -1, this property overrides the
             * [property`Gtk`.Image:icon-size] property for images of type
             * `GTK_IMAGE_ICON_NAME`.
             */
            get pixel_size(): number;
            set pixel_size(val: number);
            /**
             * The size in pixels to display icons at.
             *
             * If set to a value != -1, this property overrides the
             * [property`Gtk`.Image:icon-size] property for images of type
             * `GTK_IMAGE_ICON_NAME`.
             */
            get pixelSize(): number;
            set pixelSize(val: number);
            /**
             * A path to a resource file to display.
             */
            get resource(): string;
            set resource(val: string);
            /**
             * The representation being used for image data.
             */
            get storage_type(): ImageType;
            /**
             * The representation being used for image data.
             */
            get storageType(): ImageType;
            /**
             * Whether the icon displayed in the `GtkImage` will use
             * standard icon names fallback.
             *
             * The value of this property is only relevant for images of type
             * %GTK_IMAGE_ICON_NAME and %GTK_IMAGE_GICON.
             */
            get use_fallback(): boolean;
            set use_fallback(val: boolean);
            /**
             * Whether the icon displayed in the `GtkImage` will use
             * standard icon names fallback.
             *
             * The value of this property is only relevant for images of type
             * %GTK_IMAGE_ICON_NAME and %GTK_IMAGE_GICON.
             */
            get useFallback(): boolean;
            set useFallback(val: boolean);

            // Constructors

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

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

            static ['new'](): Image;

            static new_from_file(filename: string): Image;

            static new_from_gicon(icon: Gio.Icon): Image;

            static new_from_icon_name(icon_name?: string | null): Image;

            static new_from_paintable(paintable?: Gdk.Paintable | null): Image;

            static new_from_pixbuf(pixbuf?: GdkPixbuf.Pixbuf | null): Image;

            static new_from_resource(resource_path: string): Image;

            // Methods

            /**
             * Resets the image to be empty.
             */
            clear(): void;
            /**
             * Gets the `GIcon` being displayed by the `GtkImage`.
             *
             * The storage type of the image must be %GTK_IMAGE_EMPTY or
             * %GTK_IMAGE_GICON (see [method`Gtk`.Image.get_storage_type]).
             * The caller of this function does not own a reference to the
             * returned `GIcon`.
             * @returns a `GIcon`
             */
            get_gicon(): Gio.Icon | null;
            /**
             * Gets the icon name and size being displayed by the `GtkImage`.
             *
             * The storage type of the image must be %GTK_IMAGE_EMPTY or
             * %GTK_IMAGE_ICON_NAME (see [method`Gtk`.Image.get_storage_type]).
             * The returned string is owned by the `GtkImage` and should not
             * be freed.
             * @returns the icon name
             */
            get_icon_name(): string | null;
            /**
             * Gets the icon size used by the `image` when rendering icons.
             * @returns the image size used by icons
             */
            get_icon_size(): IconSize;
            /**
             * Gets the image `GdkPaintable` being displayed by the `GtkImage`.
             *
             * The storage type of the image must be %GTK_IMAGE_EMPTY or
             * %GTK_IMAGE_PAINTABLE (see [method`Gtk`.Image.get_storage_type]).
             * The caller of this function does not own a reference to the
             * returned paintable.
             * @returns the displayed paintable
             */
            get_paintable(): Gdk.Paintable | null;
            /**
             * Gets the pixel size used for named icons.
             * @returns the pixel size used for named icons.
             */
            get_pixel_size(): number;
            /**
             * Gets the type of representation being used by the `GtkImage`
             * to store image data.
             *
             * If the `GtkImage` has no image data, the return value will
             * be %GTK_IMAGE_EMPTY.
             * @returns image representation being used
             */
            get_storage_type(): ImageType;
            /**
             * Sets a `GtkImage` to show a file.
             *
             * See [ctor`Gtk`.Image.new_from_file] for details.
             * @param filename a filename
             */
            set_from_file(filename?: string | null): void;
            /**
             * Sets a `GtkImage` to show a `GIcon`.
             *
             * See [ctor`Gtk`.Image.new_from_gicon] for details.
             * @param icon an icon
             */
            set_from_gicon(icon: Gio.Icon): void;
            /**
             * Sets a `GtkImage` to show a named icon.
             *
             * See [ctor`Gtk`.Image.new_from_icon_name] for details.
             * @param icon_name an icon name
             */
            set_from_icon_name(icon_name?: string | null): void;
            /**
             * Sets a `GtkImage` to show a `GdkPaintable`.
             *
             * See [ctor`Gtk`.Image.new_from_paintable] for details.
             * @param paintable a `GdkPaintable`
             */
            set_from_paintable(paintable?: Gdk.Paintable | null): void;
            /**
             * Sets a `GtkImage` to show a `GdkPixbuf`.
             *
             * See [ctor`Gtk`.Image.new_from_pixbuf] for details.
             *
             * Note: This is a helper for [method`Gtk`.Image.set_from_paintable],
             * and you can't get back the exact pixbuf once this is called,
             * only a paintable.
             * @param pixbuf a `GdkPixbuf` or `NULL`
             */
            set_from_pixbuf(pixbuf?: GdkPixbuf.Pixbuf | null): void;
            /**
             * Sets a `GtkImage` to show a resource.
             *
             * See [ctor`Gtk`.Image.new_from_resource] for details.
             * @param resource_path a resource path
             */
            set_from_resource(resource_path?: string | null): void;
            /**
             * Suggests an icon size to the theme for named icons.
             * @param icon_size the new icon size
             */
            set_icon_size(icon_size: IconSize | null): void;
            /**
             * Sets the pixel size to use for named icons.
             *
             * If the pixel size is set to a value != -1, it is used instead
             * of the icon size set by [method`Gtk`.Image.set_from_icon_name].
             * @param pixel_size the new pixel size
             */
            set_pixel_size(pixel_size: number): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace InfoBar {
            // Signal callback interfaces

            interface Close {
                (): void;
            }

            interface Response {
                (response_id: number): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                message_type: MessageType;
                messageType: MessageType;
                revealed: boolean;
                show_close_button: boolean;
                showCloseButton: boolean;
            }
        }

        /**
         * `GtkInfoBar` can be used to show messages to the user without a dialog.
         *
         * ![An example GtkInfoBar](info-bar.png)
         *
         * It is often temporarily shown at the top or bottom of a document.
         * In contrast to [class`Gtk`.Dialog], which has an action area at the
         * bottom, `GtkInfoBar` has an action area at the side.
         *
         * The API of `GtkInfoBar` is very similar to `GtkDialog`, allowing you
         * to add buttons to the action area with [method`Gtk`.InfoBar.add_button]
         * or [ctor`Gtk`.InfoBar.new_with_buttons]. The sensitivity of action widgets
         * can be controlled with [method`Gtk`.InfoBar.set_response_sensitive].
         *
         * To add widgets to the main content area of a `GtkInfoBar`, use
         * [method`Gtk`.InfoBar.add_child].
         *
         * Similar to [class`Gtk`.MessageDialog], the contents of a `GtkInfoBar`
         * can by classified as error message, warning, informational message, etc,
         * by using [method`Gtk`.InfoBar.set_message_type]. GTK may use the message
         * type to determine how the message is displayed.
         *
         * A simple example for using a `GtkInfoBar`:
         * ```c
         * GtkWidget *message_label;
         * GtkWidget *widget;
         * GtkWidget *grid;
         * GtkInfoBar *bar;
         *
         * // set up info bar
         * widget = gtk_info_bar_new ();
         * bar = GTK_INFO_BAR (widget);
         * grid = gtk_grid_new ();
         *
         * message_label = gtk_label_new ("");
         * gtk_info_bar_add_child (bar, message_label);
         * gtk_info_bar_add_button (bar,
         *                          _("_OK"),
         *                          GTK_RESPONSE_OK);
         * g_signal_connect (bar,
         *                   "response",
         *                   G_CALLBACK (gtk_widget_hide),
         *                   NULL);
         * gtk_grid_attach (GTK_GRID (grid),
         *                  widget,
         *                  0, 2, 1, 1);
         *
         * // ...
         *
         * // show an error message
         * gtk_label_set_text (GTK_LABEL (message_label), "An error occurred!");
         * gtk_info_bar_set_message_type (bar, GTK_MESSAGE_ERROR);
         * gtk_widget_show (bar);
         * ```
         *
         * # GtkInfoBar as GtkBuildable
         *
         * `GtkInfoBar` supports a custom `<action-widgets>` element, which can contain
         * multiple `<action-widget>` elements. The “response” attribute specifies a
         * numeric response, and the content of the element is the id of widget
         * (which should be a child of the dialogs `action_area)`.
         *
         * `GtkInfoBar` supports adding action widgets by specifying “action” as
         * the “type” attribute of a `<child>` element. The widget will be added
         * either to the action area. The response id has to be associated
         * with the action widget using the `<action-widgets>` element.
         *
         * # CSS nodes
         *
         * `GtkInfoBar` has a single CSS node with name infobar. The node may get
         * one of the style classes .info, .warning, .error or .question, depending
         * on the message type.
         * If the info bar shows a close button, that button will have the .close
         * style class applied.
         */
        class InfoBar extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<InfoBar>;

            // Properties

            /**
             * The type of the message.
             *
             * The type may be used to determine the appearance of the info bar.
             */
            get message_type(): MessageType;
            set message_type(val: MessageType);
            /**
             * The type of the message.
             *
             * The type may be used to determine the appearance of the info bar.
             */
            get messageType(): MessageType;
            set messageType(val: MessageType);
            /**
             * Whether the info bar shows its contents.
             */
            get revealed(): boolean;
            set revealed(val: boolean);
            /**
             * Whether to include a standard close button.
             */
            get show_close_button(): boolean;
            set show_close_button(val: boolean);
            /**
             * Whether to include a standard close button.
             */
            get showCloseButton(): boolean;
            set showCloseButton(val: boolean);

            // Constructors

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

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

            static ['new'](): InfoBar;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'close', callback: (_source: this) => void): number;
            connect_after(signal: 'close', callback: (_source: this) => void): number;
            emit(signal: 'close'): void;
            connect(signal: 'response', callback: (_source: this, response_id: number) => void): number;
            connect_after(signal: 'response', callback: (_source: this, response_id: number) => void): number;
            emit(signal: 'response', response_id: number): void;

            // Methods

            /**
             * Add an activatable widget to the action area of a `GtkInfoBar`.
             *
             * This also connects a signal handler that will emit the
             * [signal`Gtk`.InfoBar::response] signal on the message area
             * when the widget is activated. The widget is appended to the
             * end of the message areas action area.
             * @param child an activatable widget
             * @param response_id response ID for @child
             */
            add_action_widget(child: Widget, response_id: number): void;
            /**
             * Adds a button with the given text.
             *
             * Clicking the button will emit the [signal`Gtk`.InfoBar::response]
             * signal with the given response_id. The button is appended to the
             * end of the info bar's action area. The button widget is returned,
             * but usually you don't need it.
             * @param button_text text of button
             * @param response_id response ID for the button
             * @returns the `GtkButton` widget that was added
             */
            add_button(button_text: string, response_id: number): Button;
            /**
             * Adds a widget to the content area of the info bar.
             * @param widget the child to be added
             */
            add_child(widget: Widget): void;
            /**
             * Returns the message type of the message area.
             * @returns the message type of the message area.
             */
            get_message_type(): MessageType;
            /**
             * Returns whether the info bar is currently revealed.
             * @returns the current value of the [property@Gtk.InfoBar:revealed] property
             */
            get_revealed(): boolean;
            /**
             * Returns whether the widget will display a standard close button.
             * @returns %TRUE if the widget displays standard close button
             */
            get_show_close_button(): boolean;
            /**
             * Removes a widget from the action area of `info_bar`.
             *
             * The widget must have been put there by a call to
             * [method`Gtk`.InfoBar.add_action_widget] or [method`Gtk`.InfoBar.add_button].
             * @param widget an action widget to remove
             */
            remove_action_widget(widget: Widget): void;
            /**
             * Removes a widget from the content area of the info bar.
             * @param widget a child that has been added to the content area
             */
            remove_child(widget: Widget): void;
            /**
             * Emits the “response” signal with the given `response_id`.
             * @param response_id a response ID
             */
            response(response_id: number): void;
            /**
             * Sets the last widget in the info bar’s action area with
             * the given response_id as the default widget for the dialog.
             *
             * Pressing “Enter” normally activates the default widget.
             *
             * Note that this function currently requires `info_bar` to
             * be added to a widget hierarchy.
             * @param response_id a response ID
             */
            set_default_response(response_id: number): void;
            /**
             * Sets the message type of the message area.
             *
             * GTK uses this type to determine how the message is displayed.
             * @param message_type a `GtkMessageType`
             */
            set_message_type(message_type: MessageType | null): void;
            /**
             * Sets the sensitivity of action widgets for `response_id`.
             *
             * Calls `gtk_widget_set_sensitive (widget, setting)` for each
             * widget in the info bars’s action area with the given `response_id`.
             * A convenient way to sensitize/desensitize buttons.
             * @param response_id a response ID
             * @param setting TRUE for sensitive
             */
            set_response_sensitive(response_id: number, setting: boolean): void;
            /**
             * Sets whether the `GtkInfoBar` is revealed.
             *
             * Changing this will make `info_bar` reveal or conceal
             * itself via a sliding transition.
             *
             * Note: this does not show or hide `info_bar` in the
             * [property`Gtk`.Widget:visible] sense, so revealing has no effect
             * if [property`Gtk`.Widget:visible] is %FALSE.
             * @param revealed The new value of the property
             */
            set_revealed(revealed: boolean): void;
            /**
             * If true, a standard close button is shown.
             *
             * When clicked it emits the response %GTK_RESPONSE_CLOSE.
             * @param setting %TRUE to include a close button
             */
            set_show_close_button(setting: boolean): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Inscription {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    AccessibleText.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                attributes: Pango.AttrList;
                markup: string;
                min_chars: number;
                minChars: number;
                min_lines: number;
                minLines: number;
                nat_chars: number;
                natChars: number;
                nat_lines: number;
                natLines: number;
                text: string;
                text_overflow: InscriptionOverflow;
                textOverflow: InscriptionOverflow;
                wrap_mode: Pango.WrapMode;
                wrapMode: Pango.WrapMode;
                xalign: number;
                yalign: number;
            }
        }

        /**
         * `GtkInscription` is a widget to show text in a predefined area.
         *
         * You likely want to use `GtkLabel` instead as this widget is intended only
         * for a small subset of use cases. The main scenario envisaged is inside lists
         * such as `GtkColumnView`.
         *
         * While a `GtkLabel` sizes itself depending on the text that is displayed,
         * `GtkInscription` is given a size and inscribes the given text into that
         * space as well as it can.
         *
         * Users of this widget should take care to plan behaviour for the common case
         * where the text doesn't fit exactly in the allocated space.
         *
         * ## CSS nodes
         *
         * `GtkInscription` has a single CSS node with the name label.
         */
        class Inscription extends Widget implements Accessible, AccessibleText, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<Inscription>;

            // Properties

            /**
             * A list of style attributes to apply to the text of the inscription.
             */
            get attributes(): Pango.AttrList;
            set attributes(val: Pango.AttrList);
            /**
             * Utility property that sets both the [property`Gtk`.Inscription:text] and
             * [property`Gtk`.Inscription:attributes] properties, mainly intended for use in
             * GtkBuilder ui files to ease translation support and bindings.
             *
             * This function uses [func`Pango`.parse_markup] to parse the markup into text and
             * attributes. The markup must be valid. If you cannot ensure that, consider using
             * [func`Pango`.parse_markup] and setting the two properties yourself.
             */
            set markup(val: string);
            /**
             * The number of characters that should fit into the inscription at minimum.
             *
             * This influences the requested width, not the width actually given to the widget,
             * which might turn out to be larger.
             *
             * Note that this is an approximate character width, so some characters might be
             * wider and some might be thinner, so do not expect the number of characters to
             * exactly match.
             *
             * If you set this property to 0, the inscription will not request any width at all
             * and its width will be determined entirely by its surroundings.
             */
            get min_chars(): number;
            set min_chars(val: number);
            /**
             * The number of characters that should fit into the inscription at minimum.
             *
             * This influences the requested width, not the width actually given to the widget,
             * which might turn out to be larger.
             *
             * Note that this is an approximate character width, so some characters might be
             * wider and some might be thinner, so do not expect the number of characters to
             * exactly match.
             *
             * If you set this property to 0, the inscription will not request any width at all
             * and its width will be determined entirely by its surroundings.
             */
            get minChars(): number;
            set minChars(val: number);
            /**
             * The number of lines that should fit into the inscription at minimum.
             *
             * This influences the requested height, not the height actually given to the widget,
             * which might turn out to be larger.
             *
             * Note that this is an approximate line height, so if the text uses things like fancy
             * Unicode or attribute that influence the height, the text might not fit.
             *
             * If you set this property to 0, the inscription will not request any height at all
             * and its height will be determined entirely by its surroundings.
             */
            get min_lines(): number;
            set min_lines(val: number);
            /**
             * The number of lines that should fit into the inscription at minimum.
             *
             * This influences the requested height, not the height actually given to the widget,
             * which might turn out to be larger.
             *
             * Note that this is an approximate line height, so if the text uses things like fancy
             * Unicode or attribute that influence the height, the text might not fit.
             *
             * If you set this property to 0, the inscription will not request any height at all
             * and its height will be determined entirely by its surroundings.
             */
            get minLines(): number;
            set minLines(val: number);
            /**
             * The number of characters that should ideally fit into the inscription.
             *
             * This influences the requested width, not the width actually given to the widget.
             * The widget might turn out larger as well as smaller.
             *
             * If this property is set to a value smaller than [property`Gtk`.Inscription:min-chars],
             * that value will be used. In particular, for the default value of 0, this will always
             * be the case.
             */
            get nat_chars(): number;
            set nat_chars(val: number);
            /**
             * The number of characters that should ideally fit into the inscription.
             *
             * This influences the requested width, not the width actually given to the widget.
             * The widget might turn out larger as well as smaller.
             *
             * If this property is set to a value smaller than [property`Gtk`.Inscription:min-chars],
             * that value will be used. In particular, for the default value of 0, this will always
             * be the case.
             */
            get natChars(): number;
            set natChars(val: number);
            /**
             * The number of lines that should ideally fit into the inscription.
             *
             * This influences the requested height, not the height actually given to the widget.
             * The widget might turn out larger as well as smaller.
             *
             * If this property is set to a value smaller than [property`Gtk`.Inscription:min-lines],
             * that value will be used. In particular, for the default value of 0, this will always
             * be the case.
             */
            get nat_lines(): number;
            set nat_lines(val: number);
            /**
             * The number of lines that should ideally fit into the inscription.
             *
             * This influences the requested height, not the height actually given to the widget.
             * The widget might turn out larger as well as smaller.
             *
             * If this property is set to a value smaller than [property`Gtk`.Inscription:min-lines],
             * that value will be used. In particular, for the default value of 0, this will always
             * be the case.
             */
            get natLines(): number;
            set natLines(val: number);
            /**
             * The displayed text.
             */
            get text(): string;
            set text(val: string);
            /**
             * The overflow method to use for the text.
             */
            get text_overflow(): InscriptionOverflow;
            set text_overflow(val: InscriptionOverflow);
            /**
             * The overflow method to use for the text.
             */
            get textOverflow(): InscriptionOverflow;
            set textOverflow(val: InscriptionOverflow);
            /**
             * Controls how the line wrapping is done.
             *
             * Note that unlike `GtkLabel`, the default here is %PANGO_WRAP_WORD_CHAR.
             */
            get wrap_mode(): Pango.WrapMode;
            set wrap_mode(val: Pango.WrapMode);
            /**
             * Controls how the line wrapping is done.
             *
             * Note that unlike `GtkLabel`, the default here is %PANGO_WRAP_WORD_CHAR.
             */
            get wrapMode(): Pango.WrapMode;
            set wrapMode(val: Pango.WrapMode);
            /**
             * The horizontal alignment of the text inside the allocated size.
             *
             * Compare this to [property`Gtk`.Widget:halign], which determines how the
             * inscription's size allocation is positioned in the available space.
             */
            get xalign(): number;
            set xalign(val: number);
            /**
             * The vertical alignment of the text inside the allocated size.
             *
             * Compare this to [property`Gtk`.Widget:valign], which determines how the
             * inscription's size allocation is positioned in the available space.
             */
            get yalign(): number;
            set yalign(val: number);

            // Constructors

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

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

            static ['new'](text?: string | null): Inscription;

            // Methods

            /**
             * Gets the inscription's attribute list.
             * @returns the attribute list
             */
            get_attributes(): Pango.AttrList | null;
            /**
             * Gets the `min-chars` of the inscription.
             *
             * See the [property`Gtk`.Inscription:min-chars] property.
             * @returns the min-chars property
             */
            get_min_chars(): number;
            /**
             * Gets the `min-lines` of the inscription.
             *
             * See the [property`Gtk`.Inscription:min-lines] property.
             * @returns the min-lines property
             */
            get_min_lines(): number;
            /**
             * Gets the `nat-chars` of the inscription.
             *
             * See the [property`Gtk`.Inscription:nat-chars] property.
             * @returns the nat-chars property
             */
            get_nat_chars(): number;
            /**
             * Gets the `nat-lines` of the inscription.
             *
             * See the [property`Gtk`.Inscription:nat-lines] property.
             * @returns the nat-lines property
             */
            get_nat_lines(): number;
            /**
             * Gets the text that is displayed.
             * @returns The displayed text
             */
            get_text(): string | null;
            /**
             * Gets the inscription's overflow method.
             * @returns the overflow method
             */
            get_text_overflow(): InscriptionOverflow;
            /**
             * Returns line wrap mode used by the inscription.
             *
             * See [method`Gtk`.Inscription.set_wrap_mode].
             * @returns the line wrap mode
             */
            get_wrap_mode(): Pango.WrapMode;
            /**
             * Gets the `xalign` of the inscription.
             *
             * See the [property`Gtk`.Inscription:xalign] property.
             * @returns the xalign property
             */
            get_xalign(): number;
            /**
             * Gets the `yalign` of the inscription.
             *
             * See the [property`Gtk`.Inscription:yalign] property.
             * @returns the yalign property
             */
            get_yalign(): number;
            /**
             * Apply attributes to the inscription text.
             *
             * These attributes will not be evaluated for sizing the inscription.
             * @param attrs a [struct@Pango.AttrList]
             */
            set_attributes(attrs?: Pango.AttrList | null): void;
            /**
             * Utility function to set the text and attributes to be displayed.
             *
             * See the [property`Gtk`.Inscription:markup] property.
             * @param markup The markup to display
             */
            set_markup(markup?: string | null): void;
            /**
             * Sets the `min-chars` of the inscription.
             *
             * See the [property`Gtk`.Inscription:min-chars] property.
             * @param min_chars the minimum number of characters that should fit, approximately
             */
            set_min_chars(min_chars: number): void;
            /**
             * Sets the `min-lines` of the inscription.
             *
             * See the [property`Gtk`.Inscription:min-lines] property.
             * @param min_lines the minimum number of lines that should fit, approximately
             */
            set_min_lines(min_lines: number): void;
            /**
             * Sets the `nat-chars` of the inscription.
             *
             * See the [property`Gtk`.Inscription:nat-chars] property.
             * @param nat_chars the number of characters that should ideally fit, approximately
             */
            set_nat_chars(nat_chars: number): void;
            /**
             * Sets the `nat-lines` of the inscription.
             *
             * See the [property`Gtk`.Inscription:nat-lines] property.
             * @param nat_lines the number of lines that should ideally fit
             */
            set_nat_lines(nat_lines: number): void;
            /**
             * Sets the text to be displayed.
             * @param text The text to display
             */
            set_text(text?: string | null): void;
            /**
             * Sets what to do when the text doesn't fit.
             * @param overflow the overflow method to use
             */
            set_text_overflow(overflow: InscriptionOverflow | null): void;
            /**
             * Controls how line wrapping is done.
             * @param wrap_mode the line wrapping mode
             */
            set_wrap_mode(wrap_mode: Pango.WrapMode | null): void;
            /**
             * Sets the `xalign` of the inscription.
             *
             * See the [property`Gtk`.Inscription:xalign] property.
             * @param xalign the new xalign value, between 0 and 1
             */
            set_xalign(xalign: number): void;
            /**
             * Sets the `yalign` of the inscription.
             *
             * See the [property`Gtk`.Inscription:yalign] property.
             * @param yalign the new yalign value, between 0 and 1
             */
            set_yalign(yalign: number): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Updates the position of the caret.
             *
             * Implementations of the `GtkAccessibleText` interface should call this
             * function every time the caret has moved, in order to notify assistive
             * technologies.
             */
            update_caret_position(): void;
            /**
             * Notifies assistive technologies of a change in contents.
             *
             * Implementations of the `GtkAccessibleText` interface should call this
             * function every time their contents change as the result of an operation,
             * like an insertion or a removal.
             *
             * Note: If the change is a deletion, this function must be called *before*
             * removing the contents, if it is an insertion, it must be called *after*
             * inserting the new contents.
             * @param change the type of change in the contents
             * @param start the starting offset of the change, in characters
             * @param end the end offset of the change, in characters
             */
            update_contents(change: AccessibleTextContentChange | null, start: number, end: number): void;
            /**
             * Updates the boundary of the selection.
             *
             * Implementations of the `GtkAccessibleText` interface should call this
             * function every time the selection has moved, in order to notify assistive
             * technologies.
             */
            update_selection_bound(): void;
            /**
             * Retrieves the text attributes inside the accessible object.
             *
             * Each attribute is composed by:
             *
             * - a range
             * - a name
             * - a value
             *
             * It is left to the implementation to determine the serialization format
             * of the value to a string.
             *
             * GTK provides support for various text attribute names and values, but
             * implementations of this interface are free to add their own attributes.
             *
             * If this function returns true, `n_ranges` will be set to a value
             * greater than or equal to one, `ranges` will be set to a newly
             * allocated array of [struct#Gtk.AccessibleTextRange].
             * @param offset the offset, in characters
             */
            vfunc_get_attributes(
                offset: number,
            ): [boolean, AccessibleTextRange[] | null, string[] | null, string[] | null];
            /**
             * Retrieves the position of the caret inside the accessible object.
             */
            vfunc_get_caret_position(): number;
            /**
             * Retrieve the current contents of the accessible object within
             * the given range.
             *
             * If `end` is `G_MAXUINT`, the end of the range is the full content
             * of the accessible object.
             * @param start the beginning of the range, in characters
             * @param end the end of the range, in characters
             */
            vfunc_get_contents(start: number, end: number): GLib.Bytes;
            /**
             * Retrieve the current contents of the accessible object starting
             * from the given offset, and using the given granularity.
             *
             * The `start` and `end` values contain the boundaries of the text.
             * @param offset the offset, in characters
             * @param granularity the granularity of the query
             */
            vfunc_get_contents_at(offset: number, granularity: AccessibleTextGranularity): [GLib.Bytes, number, number];
            /**
             * Retrieves the default text attributes inside the accessible object.
             *
             * Each attribute is composed by:
             *
             * - a name
             * - a value
             *
             * It is left to the implementation to determine the serialization format
             * of the value to a string.
             *
             * GTK provides support for various text attribute names and values, but
             * implementations of this interface are free to add their own attributes.
             */
            vfunc_get_default_attributes(): [string[] | null, string[] | null];
            /**
             * Obtains the extents of a range of text, in widget coordinates.
             * @param start the start offset, in characters
             * @param end the end offset, in characters, @extents (out caller-allocates): return location for the extents
             * @param extents
             */
            vfunc_get_extents(start: number, end: number, extents: Graphene.Rect): boolean;
            /**
             * Gets the text offset at a given point.
             * @param point a point in widget coordinates of @self
             */
            vfunc_get_offset(point: Graphene.Point): [boolean, number];
            /**
             * Retrieves the selection ranges in the accessible object.
             *
             * If this function returns true, `n_ranges` will be set to a value
             * greater than or equal to one, and `ranges` will be set to a newly
             * allocated array of [struct#Gtk.AccessibleTextRange].
             */
            vfunc_get_selection(): [boolean, AccessibleTextRange[] | null];
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace KeyvalTrigger {
            // Constructor properties interface

            interface ConstructorProps extends ShortcutTrigger.ConstructorProps {
                keyval: number;
                modifiers: Gdk.ModifierType;
            }
        }

        /**
         * A `GtkShortcutTrigger` that triggers when a specific keyval and modifiers are pressed.
         */
        class KeyvalTrigger extends ShortcutTrigger {
            static $gtype: GObject.GType<KeyvalTrigger>;

            // Properties

            /**
             * The key value for the trigger.
             */
            get keyval(): number;
            /**
             * The key modifiers for the trigger.
             */
            get modifiers(): Gdk.ModifierType;

            // Constructors

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

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

            static ['new'](keyval: number, modifiers: Gdk.ModifierType): KeyvalTrigger;

            // Methods

            /**
             * Gets the keyval that must be pressed to succeed
             * triggering `self`.
             * @returns the keyval
             */
            get_keyval(): number;
            /**
             * Gets the modifiers that must be present to succeed
             * triggering `self`.
             * @returns the modifiers
             */
            get_modifiers(): Gdk.ModifierType;
        }

        namespace Label {
            // Signal callback interfaces

            interface ActivateCurrentLink {
                (): void;
            }

            interface ActivateLink {
                (uri: string): boolean;
            }

            interface CopyClipboard {
                (): void;
            }

            interface MoveCursor {
                (step: MovementStep, count: number, extend_selection: boolean): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    AccessibleText.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                attributes: Pango.AttrList;
                ellipsize: Pango.EllipsizeMode;
                extra_menu: Gio.MenuModel;
                extraMenu: Gio.MenuModel;
                justify: Justification;
                label: string;
                lines: number;
                max_width_chars: number;
                maxWidthChars: number;
                mnemonic_keyval: number;
                mnemonicKeyval: number;
                mnemonic_widget: Widget;
                mnemonicWidget: Widget;
                natural_wrap_mode: NaturalWrapMode;
                naturalWrapMode: NaturalWrapMode;
                selectable: boolean;
                single_line_mode: boolean;
                singleLineMode: boolean;
                tabs: Pango.TabArray;
                use_markup: boolean;
                useMarkup: boolean;
                use_underline: boolean;
                useUnderline: boolean;
                width_chars: number;
                widthChars: number;
                wrap: boolean;
                wrap_mode: Pango.WrapMode;
                wrapMode: Pango.WrapMode;
                xalign: number;
                yalign: number;
            }
        }

        /**
         * The `GtkLabel` widget displays a small amount of text.
         *
         * As the name implies, most labels are used to label another widget
         * such as a [class`Button]`.
         *
         * ![An example GtkLabel](label.png)
         *
         * ## Shortcuts and Gestures
         *
         * `GtkLabel` supports the following keyboard shortcuts, when the cursor is
         * visible:
         *
         * - <kbd>Shift</kbd>+<kbd>F10</kbd> or <kbd>Menu</kbd> opens the context menu.
         * - <kbd>Ctrl</kbd>+<kbd>A</kbd> or <kbd>Ctrl</kbd>+<kbd>&sol;</kbd>
         *   selects all.
         * - <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>A</kbd> or
         *   <kbd>Ctrl</kbd>+<kbd>&bsol;</kbd> unselects all.
         *
         * Additionally, the following signals have default keybindings:
         *
         * - [signal`Gtk`.Label::activate-current-link]
         * - [signal`Gtk`.Label::copy-clipboard]
         * - [signal`Gtk`.Label::move-cursor]
         *
         * ## Actions
         *
         * `GtkLabel` defines a set of built-in actions:
         *
         * - `clipboard.copy` copies the text to the clipboard.
         * - `clipboard.cut` doesn't do anything, since text in labels can't be deleted.
         * - `clipboard.paste` doesn't do anything, since text in labels can't be
         *   edited.
         * - `link.open` opens the link, when activated on a link inside the label.
         * - `link.copy` copies the link to the clipboard, when activated on a link
         *   inside the label.
         * - `menu.popup` opens the context menu.
         * - `selection.delete` doesn't do anything, since text in labels can't be
         *   deleted.
         * - `selection.select-all` selects all of the text, if the label allows
         *   selection.
         *
         * ## CSS nodes
         *
         * ```
         * label
         * ├── [selection]
         * ├── [link]
         * ┊
         * ╰── [link]
         * ```
         *
         * `GtkLabel` has a single CSS node with the name label. A wide variety
         * of style classes may be applied to labels, such as .title, .subtitle,
         * .dim-label, etc. In the `GtkShortcutsWindow`, labels are used with the
         * .keycap style class.
         *
         * If the label has a selection, it gets a subnode with name selection.
         *
         * If the label has links, there is one subnode per link. These subnodes
         * carry the link or visited state depending on whether they have been
         * visited. In this case, label node also gets a .link style class.
         *
         * ## GtkLabel as GtkBuildable
         *
         * The GtkLabel implementation of the GtkBuildable interface supports a
         * custom `<attributes>` element, which supports any number of `<attribute>`
         * elements. The `<attribute>` element has attributes named “name“, “value“,
         * “start“ and “end“ and allows you to specify [struct`Pango`.Attribute]
         * values for this label.
         *
         * An example of a UI definition fragment specifying Pango attributes:
         *
         * ```xml
         * <object class="GtkLabel">
         *   <attributes>
         *     <attribute name="weight" value="PANGO_WEIGHT_BOLD"/>
         *     <attribute name="background" value="red" start="5" end="10"/>
         *   </attributes>
         * </object>
         * ```
         *
         * The start and end attributes specify the range of characters to which the
         * Pango attribute applies. If start and end are not specified, the attribute is
         * applied to the whole text. Note that specifying ranges does not make much
         * sense with translatable attributes. Use markup embedded in the translatable
         * content instead.
         *
         * ## Accessibility
         *
         * `GtkLabel` uses the %GTK_ACCESSIBLE_ROLE_LABEL role.
         *
         * ## Mnemonics
         *
         * Labels may contain “mnemonics”. Mnemonics are underlined characters in the
         * label, used for keyboard navigation. Mnemonics are created by providing a
         * string with an underscore before the mnemonic character, such as `"_File"`,
         * to the functions [ctor`Gtk`.Label.new_with_mnemonic] or
         * [method`Gtk`.Label.set_text_with_mnemonic].
         *
         * Mnemonics automatically activate any activatable widget the label is
         * inside, such as a [class`Gtk`.Button]; if the label is not inside the
         * mnemonic’s target widget, you have to tell the label about the target
         * using [method`Gtk`.Label.set_mnemonic_widget].
         *
         * Here’s a simple example where the label is inside a button:
         *
         * ```c
         * // Pressing Alt+H will activate this button
         * GtkWidget *button = gtk_button_new ();
         * GtkWidget *label = gtk_label_new_with_mnemonic ("_Hello");
         * gtk_button_set_child (GTK_BUTTON (button), label);
         * ```
         *
         * There’s a convenience function to create buttons with a mnemonic label
         * already inside:
         *
         * ```c
         * // Pressing Alt+H will activate this button
         * GtkWidget *button = gtk_button_new_with_mnemonic ("_Hello");
         * ```
         *
         * To create a mnemonic for a widget alongside the label, such as a
         * [class`Gtk`.Entry], you have to point the label at the entry with
         * [method`Gtk`.Label.set_mnemonic_widget]:
         *
         * ```c
         * // Pressing Alt+H will focus the entry
         * GtkWidget *entry = gtk_entry_new ();
         * GtkWidget *label = gtk_label_new_with_mnemonic ("_Hello");
         * gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);
         * ```
         *
         * ## Markup (styled text)
         *
         * To make it easy to format text in a label (changing colors,
         * fonts, etc.), label text can be provided in a simple
         * markup format:
         *
         * Here’s how to create a label with a small font:
         * ```c
         * GtkWidget *label = gtk_label_new (NULL);
         * gtk_label_set_markup (GTK_LABEL (label), "<small>Small text</small>");
         * ```
         *
         * (See the Pango manual for complete documentation] of available
         * tags, [func`Pango`.parse_markup])
         *
         * The markup passed to [method`Gtk`.Label.set_markup] must be valid; for example,
         * literal `<`, `>` and `&` characters must be escaped as `&lt;`, `&gt;`, and `&amp;`.
         * If you pass text obtained from the user, file, or a network to
         * [method`Gtk`.Label.set_markup], you’ll want to escape it with
         * [func`GLib`.markup_escape_text] or [func`GLib`.markup_printf_escaped].
         *
         * Markup strings are just a convenient way to set the [struct`Pango`.AttrList]
         * on a label; [method`Gtk`.Label.set_attributes] may be a simpler way to set
         * attributes in some cases. Be careful though; [struct`Pango`.AttrList] tends
         * to cause internationalization problems, unless you’re applying attributes
         * to the entire string (i.e. unless you set the range of each attribute
         * to [0, %G_MAXINT)). The reason is that specifying the start_index and
         * end_index for a [struct`Pango`.Attribute] requires knowledge of the exact
         * string being displayed, so translations will cause problems.
         *
         * ## Selectable labels
         *
         * Labels can be made selectable with [method`Gtk`.Label.set_selectable].
         * Selectable labels allow the user to copy the label contents to
         * the clipboard. Only labels that contain useful-to-copy information—such
         * as error messages—should be made selectable.
         *
         * ## Text layout
         *
         * A label can contain any number of paragraphs, but will have
         * performance problems if it contains more than a small number.
         * Paragraphs are separated by newlines or other paragraph separators
         * understood by Pango.
         *
         * Labels can automatically wrap text if you call [method`Gtk`.Label.set_wrap].
         *
         * [method`Gtk`.Label.set_justify] sets how the lines in a label align
         * with one another. If you want to set how the label as a whole aligns
         * in its available space, see the [property`Gtk`.Widget:halign] and
         * [property`Gtk`.Widget:valign] properties.
         *
         * The [property`Gtk`.Label:width-chars] and [property`Gtk`.Label:max-width-chars]
         * properties can be used to control the size allocation of ellipsized or
         * wrapped labels. For ellipsizing labels, if either is specified (and less
         * than the actual text size), it is used as the minimum width, and the actual
         * text size is used as the natural width of the label. For wrapping labels,
         * width-chars is used as the minimum width, if specified, and max-width-chars
         * is used as the natural width. Even if max-width-chars specified, wrapping
         * labels will be rewrapped to use all of the available width.
         *
         * ## Links
         *
         * GTK supports markup for clickable hyperlinks in addition to regular Pango
         * markup. The markup for links is borrowed from HTML, using the `<a>` with
         * “href“, “title“ and “class“ attributes. GTK renders links similar to the
         * way they appear in web browsers, with colored, underlined text. The “title“
         * attribute is displayed as a tooltip on the link. The “class“ attribute is
         * used as style class on the CSS node for the link.
         *
         * An example of inline links looks like this:
         *
         * ```c
         * const char *text =
         * "Go to the "
         * "<a href=\"https://www.gtk.org\" title=\"&lt;i&gt;Our&lt;/i&gt; website\">"
         * "GTK website</a> for more...";
         * GtkWidget *label = gtk_label_new (NULL);
         * gtk_label_set_markup (GTK_LABEL (label), text);
         * ```
         *
         * It is possible to implement custom handling for links and their tooltips
         * with the [signal`Gtk`.Label::activate-link] signal and the
         * [method`Gtk`.Label.get_current_uri] function.
         */
        class Label extends Widget implements Accessible, AccessibleText, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<Label>;

            // Properties

            /**
             * A list of style attributes to apply to the text of the label.
             */
            get attributes(): Pango.AttrList;
            set attributes(val: Pango.AttrList);
            /**
             * The preferred place to ellipsize the string, if the label does
             * not have enough room to display the entire string.
             *
             * Note that setting this property to a value other than
             * %PANGO_ELLIPSIZE_NONE has the side-effect that the label requests
             * only enough space to display the ellipsis "...". In particular, this
             * means that ellipsizing labels do not work well in notebook tabs, unless
             * the [property`Gtk`.NotebookPage:tab-expand] child property is set to %TRUE.
             * Other ways to set a label's width are [method`Gtk`.Widget.set_size_request]
             * and [method`Gtk`.Label.set_width_chars].
             */
            get ellipsize(): Pango.EllipsizeMode;
            set ellipsize(val: Pango.EllipsizeMode);
            /**
             * A menu model whose contents will be appended to the context menu.
             */
            get extra_menu(): Gio.MenuModel;
            set extra_menu(val: Gio.MenuModel);
            /**
             * A menu model whose contents will be appended to the context menu.
             */
            get extraMenu(): Gio.MenuModel;
            set extraMenu(val: Gio.MenuModel);
            /**
             * The alignment of the lines in the text of the label, relative to each other.
             *
             * This does *not* affect the alignment of the label within its allocation.
             * See [property`Gtk`.Label:xalign] for that.
             */
            get justify(): Justification;
            set justify(val: Justification);
            /**
             * The contents of the label.
             *
             * If the string contains Pango markup (see [func`Pango`.parse_markup]),
             * you will have to set the [property`Gtk`.Label:use-markup] property to
             * %TRUE in order for the label to display the markup attributes. See also
             * [method`Gtk`.Label.set_markup] for a convenience function that sets both
             * this property and the [property`Gtk`.Label:use-markup] property at the
             * same time.
             *
             * If the string contains underlines acting as mnemonics, you will have to
             * set the [property`Gtk`.Label:use-underline] property to %TRUE in order
             * for the label to display them.
             */
            get label(): string;
            set label(val: string);
            /**
             * The number of lines to which an ellipsized, wrapping label
             * should be limited.
             *
             * This property has no effect if the label is not wrapping or ellipsized.
             * Set this property to -1 if you don't want to limit the number of lines.
             */
            get lines(): number;
            set lines(val: number);
            /**
             * The desired maximum width of the label, in characters.
             *
             * If this property is set to -1, the width will be calculated automatically.
             *
             * See the section on [text layout](class.Label.html#text-layout) for details of how
             * [property`Gtk`.Label:width-chars] and [property`Gtk`.Label:max-width-chars]
             * determine the width of ellipsized and wrapped labels.
             */
            get max_width_chars(): number;
            set max_width_chars(val: number);
            /**
             * The desired maximum width of the label, in characters.
             *
             * If this property is set to -1, the width will be calculated automatically.
             *
             * See the section on [text layout](class.Label.html#text-layout) for details of how
             * [property`Gtk`.Label:width-chars] and [property`Gtk`.Label:max-width-chars]
             * determine the width of ellipsized and wrapped labels.
             */
            get maxWidthChars(): number;
            set maxWidthChars(val: number);
            /**
             * The mnemonic accelerator key for the label.
             */
            get mnemonic_keyval(): number;
            /**
             * The mnemonic accelerator key for the label.
             */
            get mnemonicKeyval(): number;
            /**
             * The widget to be activated when the labels mnemonic key is pressed.
             */
            get mnemonic_widget(): Widget;
            set mnemonic_widget(val: Widget);
            /**
             * The widget to be activated when the labels mnemonic key is pressed.
             */
            get mnemonicWidget(): Widget;
            set mnemonicWidget(val: Widget);
            /**
             * Select the line wrapping for the natural size request.
             *
             * This only affects the natural size requested. For the actual wrapping used,
             * see the [property`Gtk`.Label:wrap-mode] property.
             *
             * The default is %GTK_NATURAL_WRAP_INHERIT, which inherits the behavior of the
             * [property`Gtk`.Label:wrap-mode] property.
             */
            get natural_wrap_mode(): NaturalWrapMode;
            set natural_wrap_mode(val: NaturalWrapMode);
            /**
             * Select the line wrapping for the natural size request.
             *
             * This only affects the natural size requested. For the actual wrapping used,
             * see the [property`Gtk`.Label:wrap-mode] property.
             *
             * The default is %GTK_NATURAL_WRAP_INHERIT, which inherits the behavior of the
             * [property`Gtk`.Label:wrap-mode] property.
             */
            get naturalWrapMode(): NaturalWrapMode;
            set naturalWrapMode(val: NaturalWrapMode);
            /**
             * Whether the label text can be selected with the mouse.
             */
            get selectable(): boolean;
            set selectable(val: boolean);
            /**
             * Whether the label is in single line mode.
             *
             * In single line mode, the height of the label does not depend on the
             * actual text, it is always set to ascent + descent of the font. This
             * can be an advantage in situations where resizing the label because
             * of text changes would be distracting, e.g. in a statusbar.
             */
            get single_line_mode(): boolean;
            set single_line_mode(val: boolean);
            /**
             * Whether the label is in single line mode.
             *
             * In single line mode, the height of the label does not depend on the
             * actual text, it is always set to ascent + descent of the font. This
             * can be an advantage in situations where resizing the label because
             * of text changes would be distracting, e.g. in a statusbar.
             */
            get singleLineMode(): boolean;
            set singleLineMode(val: boolean);
            /**
             * Custom tabs for this label.
             */
            get tabs(): Pango.TabArray;
            set tabs(val: Pango.TabArray);
            /**
             * %TRUE if the text of the label includes Pango markup.
             *
             * See [func`Pango`.parse_markup].
             */
            get use_markup(): boolean;
            set use_markup(val: boolean);
            /**
             * %TRUE if the text of the label includes Pango markup.
             *
             * See [func`Pango`.parse_markup].
             */
            get useMarkup(): boolean;
            set useMarkup(val: boolean);
            /**
             * %TRUE if the text of the label indicates a mnemonic with an _
             * before the mnemonic character.
             */
            get use_underline(): boolean;
            set use_underline(val: boolean);
            /**
             * %TRUE if the text of the label indicates a mnemonic with an _
             * before the mnemonic character.
             */
            get useUnderline(): boolean;
            set useUnderline(val: boolean);
            /**
             * The desired width of the label, in characters.
             *
             * If this property is set to -1, the width will be calculated automatically.
             *
             * See the section on [text layout](class.Label.html#text-layout) for details of how
             * [property`Gtk`.Label:width-chars] and [property`Gtk`.Label:max-width-chars]
             * determine the width of ellipsized and wrapped labels.
             */
            get width_chars(): number;
            set width_chars(val: number);
            /**
             * The desired width of the label, in characters.
             *
             * If this property is set to -1, the width will be calculated automatically.
             *
             * See the section on [text layout](class.Label.html#text-layout) for details of how
             * [property`Gtk`.Label:width-chars] and [property`Gtk`.Label:max-width-chars]
             * determine the width of ellipsized and wrapped labels.
             */
            get widthChars(): number;
            set widthChars(val: number);
            /**
             * %TRUE if the label text will wrap if it gets too wide.
             */
            get wrap(): boolean;
            set wrap(val: boolean);
            /**
             * Controls how the line wrapping is done.
             *
             * This only affects the formatting if line wrapping is on (see the
             * [property`Gtk`.Label:wrap] property). The default is %PANGO_WRAP_WORD,
             * which means wrap on word boundaries.
             *
             * For sizing behavior, also consider the [property`Gtk`.Label:natural-wrap-mode]
             * property.
             */
            get wrap_mode(): Pango.WrapMode;
            set wrap_mode(val: Pango.WrapMode);
            /**
             * Controls how the line wrapping is done.
             *
             * This only affects the formatting if line wrapping is on (see the
             * [property`Gtk`.Label:wrap] property). The default is %PANGO_WRAP_WORD,
             * which means wrap on word boundaries.
             *
             * For sizing behavior, also consider the [property`Gtk`.Label:natural-wrap-mode]
             * property.
             */
            get wrapMode(): Pango.WrapMode;
            set wrapMode(val: Pango.WrapMode);
            /**
             * The horizontal alignment of the label text inside its size allocation.
             *
             * Compare this to [property`Gtk`.Widget:halign], which determines how the
             * labels size allocation is positioned in the space available for the label.
             */
            get xalign(): number;
            set xalign(val: number);
            /**
             * The vertical alignment of the label text inside its size allocation.
             *
             * Compare this to [property`Gtk`.Widget:valign], which determines how the
             * labels size allocation is positioned in the space available for the label.
             */
            get yalign(): number;
            set yalign(val: number);

            // Constructors

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

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

            static ['new'](str?: string | null): Label;

            static new_with_mnemonic(str?: string | null): Label;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate-current-link', callback: (_source: this) => void): number;
            connect_after(signal: 'activate-current-link', callback: (_source: this) => void): number;
            emit(signal: 'activate-current-link'): void;
            connect(signal: 'activate-link', callback: (_source: this, uri: string) => boolean): number;
            connect_after(signal: 'activate-link', callback: (_source: this, uri: string) => boolean): number;
            emit(signal: 'activate-link', uri: string): void;
            connect(signal: 'copy-clipboard', callback: (_source: this) => void): number;
            connect_after(signal: 'copy-clipboard', callback: (_source: this) => void): number;
            emit(signal: 'copy-clipboard'): void;
            connect(
                signal: 'move-cursor',
                callback: (_source: this, step: MovementStep, count: number, extend_selection: boolean) => void,
            ): number;
            connect_after(
                signal: 'move-cursor',
                callback: (_source: this, step: MovementStep, count: number, extend_selection: boolean) => void,
            ): number;
            emit(signal: 'move-cursor', step: MovementStep, count: number, extend_selection: boolean): void;

            // Methods

            /**
             * Gets the label's attribute list.
             *
             * This is the [struct`Pango`.AttrList] that was set on the label using
             * [method`Gtk`.Label.set_attributes], if any. This function does not
             * reflect attributes that come from the label's markup (see
             * [method`Gtk`.Label.set_markup]). If you want to get the effective
             * attributes for the label, use
             * `pango_layout_get_attributes (gtk_label_get_layout (self))`.
             * @returns the attribute list
             */
            get_attributes(): Pango.AttrList | null;
            /**
             * Returns the URI for the currently active link in the label.
             *
             * The active link is the one under the mouse pointer or, in a
             * selectable label, the link in which the text cursor is currently
             * positioned.
             *
             * This function is intended for use in a [signal`Gtk`.Label::activate-link]
             * handler or for use in a [signal`Gtk`.Widget::query-tooltip] handler.
             * @returns the currently active URI
             */
            get_current_uri(): string | null;
            /**
             * Returns the ellipsizing position of the label.
             *
             * See [method`Gtk`.Label.set_ellipsize].
             * @returns `PangoEllipsizeMode`
             */
            get_ellipsize(): Pango.EllipsizeMode;
            /**
             * Gets the extra menu model of `label`.
             *
             * See [method`Gtk`.Label.set_extra_menu].
             * @returns the menu model
             */
            get_extra_menu(): Gio.MenuModel | null;
            /**
             * Returns the justification of the label.
             *
             * See [method`Gtk`.Label.set_justify].
             * @returns `GtkJustification`
             */
            get_justify(): Justification;
            /**
             * Fetches the text from a label.
             *
             * The returned text includes any embedded underlines indicating
             * mnemonics and Pango markup. (See [method`Gtk`.Label.get_text]).
             * @returns the text of the label widget. This string is   owned by the widget and must not be modified or freed.
             */
            get_label(): string;
            /**
             * Gets the `PangoLayout` used to display the label.
             *
             * The layout is useful to e.g. convert text positions to pixel
             * positions, in combination with [method`Gtk`.Label.get_layout_offsets].
             * The returned layout is owned by the `label` so need not be
             * freed by the caller. The `label` is free to recreate its layout
             * at any time, so it should be considered read-only.
             * @returns the [class@Pango.Layout] for this label
             */
            get_layout(): Pango.Layout;
            /**
             * Obtains the coordinates where the label will draw its `PangoLayout`.
             *
             * The coordinates are useful to convert mouse events into coordinates
             * inside the [class`Pango`.Layout], e.g. to take some action if some part
             * of the label is clicked. Remember when using the [class`Pango`.Layout]
             * functions you need to convert to and from pixels using PANGO_PIXELS()
             * or [const`Pango`.SCALE].
             */
            get_layout_offsets(): [number, number];
            /**
             * Gets the number of lines to which an ellipsized, wrapping
             * label should be limited.
             *
             * See [method`Gtk`.Label.set_lines].
             * @returns The number of lines
             */
            get_lines(): number;
            /**
             * Retrieves the desired maximum width of `label,` in characters.
             *
             * See [method`Gtk`.Label.set_width_chars].
             * @returns the maximum width of the label in characters.
             */
            get_max_width_chars(): number;
            /**
             * Return the mnemonic accelerator.
             *
             * If the label has been set so that it has a mnemonic key this function
             * returns the keyval used for the mnemonic accelerator. If there is no
             * mnemonic set up it returns `GDK_KEY_VoidSymbol`.
             * @returns GDK keyval usable for accelerators, or `GDK_KEY_VoidSymbol`
             */
            get_mnemonic_keyval(): number;
            /**
             * Retrieves the target of the mnemonic (keyboard shortcut) of this
             * label.
             *
             * See [method`Gtk`.Label.set_mnemonic_widget].
             * @returns the target of the label’s mnemonic,   or %NULL if none has been set and the default algorithm will be used.
             */
            get_mnemonic_widget(): Widget | null;
            /**
             * Returns line wrap mode used by the label.
             *
             * See [method`Gtk`.Label.set_natural_wrap_mode].
             * @returns the natural line wrap mode
             */
            get_natural_wrap_mode(): NaturalWrapMode;
            /**
             * Returns whether the label is selectable.
             * @returns %TRUE if the user can copy text from the label
             */
            get_selectable(): boolean;
            /**
             * Gets the selected range of characters in the label.
             * @returns %TRUE if selection is non-empty
             */
            get_selection_bounds(): [boolean, number, number];
            /**
             * Returns whether the label is in single line mode.
             * @returns %TRUE when the label is in single line mode.
             */
            get_single_line_mode(): boolean;
            /**
             * Gets the tabs for `self`.
             *
             * The returned array will be %NULL if “standard” (8-space) tabs are used.
             * Free the return value with [method`Pango`.TabArray.free].
             * @returns copy of default tab array,   or %NULL if standard tabs are used; must be freed with   [method@Pango.TabArray.free].
             */
            get_tabs(): Pango.TabArray | null;
            /**
             * Fetches the text from a label.
             *
             * The returned text is as it appears on screen. This does not include
             * any embedded underlines indicating mnemonics or Pango markup. (See
             * [method`Gtk`.Label.get_label])
             * @returns the text in the label widget. This is the internal   string used by the label, and must not be modified.
             */
            get_text(): string;
            /**
             * Returns whether the label’s text is interpreted as Pango markup.
             *
             * See [method`Gtk`.Label.set_use_markup].
             * @returns %TRUE if the label’s text will be parsed for markup.
             */
            get_use_markup(): boolean;
            /**
             * Returns whether an embedded underlines in the label indicate mnemonics.
             *
             * See [method`Gtk`.Label.set_use_underline].
             * @returns %TRUE whether an embedded underline in the label indicates   the mnemonic accelerator keys.
             */
            get_use_underline(): boolean;
            /**
             * Retrieves the desired width of `label,` in characters.
             *
             * See [method`Gtk`.Label.set_width_chars].
             * @returns the width of the label in characters.
             */
            get_width_chars(): number;
            /**
             * Returns whether lines in the label are automatically wrapped.
             *
             * See [method`Gtk`.Label.set_wrap].
             * @returns %TRUE if the lines of the label are automatically wrapped.
             */
            get_wrap(): boolean;
            /**
             * Returns line wrap mode used by the label.
             *
             * See [method`Gtk`.Label.set_wrap_mode].
             * @returns the line wrap mode
             */
            get_wrap_mode(): Pango.WrapMode;
            /**
             * Gets the `xalign` of the label.
             *
             * See the [property`Gtk`.Label:xalign] property.
             * @returns the xalign property
             */
            get_xalign(): number;
            /**
             * Gets the `yalign` of the label.
             *
             * See the [property`Gtk`.Label:yalign] property.
             * @returns the yalign property
             */
            get_yalign(): number;
            /**
             * Selects a range of characters in the label, if the label is selectable.
             *
             * See [method`Gtk`.Label.set_selectable]. If the label is not selectable,
             * this function has no effect. If `start_offset` or
             * `end_offset` are -1, then the end of the label will be substituted.
             * @param start_offset start offset (in characters not bytes)
             * @param end_offset end offset (in characters not bytes)
             */
            select_region(start_offset: number, end_offset: number): void;
            /**
             * Apply attributes to the label text.
             *
             * The attributes set with this function will be applied and merged with
             * any other attributes previously effected by way of the
             * [property`Gtk`.Label:use-underline] or [property`Gtk`.Label:use-markup]
             * properties. While it is not recommended to mix markup strings with
             * manually set attributes, if you must; know that the attributes will
             * be applied to the label after the markup string is parsed.
             * @param attrs a [struct@Pango.AttrList]
             */
            set_attributes(attrs?: Pango.AttrList | null): void;
            /**
             * Sets the mode used to ellipsize the text.
             *
             * The text will be ellipsized if there is not enough space
             * to render the entire string.
             * @param mode a `PangoEllipsizeMode`
             */
            set_ellipsize(mode: Pango.EllipsizeMode | null): void;
            /**
             * Sets a menu model to add when constructing
             * the context menu for `label`.
             * @param model a `GMenuModel`
             */
            set_extra_menu(model?: Gio.MenuModel | null): void;
            /**
             * Sets the alignment of the lines in the text of the label relative to
             * each other.
             *
             * %GTK_JUSTIFY_LEFT is the default value when the widget is first created
             * with [ctor`Gtk`.Label.new]. If you instead want to set the alignment of
             * the label as a whole, use [method`Gtk`.Widget.set_halign] instead.
             * [method`Gtk`.Label.set_justify] has no effect on labels containing
             * only a single line.
             * @param jtype a `GtkJustification`
             */
            set_justify(jtype: Justification | null): void;
            /**
             * Sets the text of the label.
             *
             * The label is interpreted as including embedded underlines and/or Pango
             * markup depending on the values of the [property`Gtk`.Label:use-underline]
             * and [property`Gtk`.Label:use-markup] properties.
             * @param str the new text to set for the label
             */
            set_label(str: string): void;
            /**
             * Sets the number of lines to which an ellipsized, wrapping label
             * should be limited.
             *
             * This has no effect if the label is not wrapping or ellipsized.
             * Set this to -1 if you don’t want to limit the number of lines.
             * @param lines the desired number of lines, or -1
             */
            set_lines(lines: number): void;
            /**
             * Sets the labels text and attributes from markup.
             *
             * The string must be marked up with Pango markup
             * (see [func`Pango`.parse_markup]).
             *
             * If the `str` is external data, you may need to escape it
             * with g_markup_escape_text() or g_markup_printf_escaped():
             *
             * ```c
             * GtkWidget *self = gtk_label_new (NULL);
             * const char *str = "...";
             * const char *format = "<span style=\"italic\">\%s</span>";
             * char *markup;
             *
             * markup = g_markup_printf_escaped (format, str);
             * gtk_label_set_markup (GTK_LABEL (self), markup);
             * g_free (markup);
             * ```
             *
             * This function will set the [property`Gtk`.Label:use-markup] property
             * to %TRUE as a side effect.
             *
             * If you set the label contents using the [property`Gtk`.Label:label]
             * property you should also ensure that you set the
             * [property`Gtk`.Label:use-markup] property accordingly.
             *
             * See also: [method`Gtk`.Label.set_text]
             * @param str a markup string
             */
            set_markup(str: string): void;
            /**
             * Sets the labels text, attributes and mnemonic from markup.
             *
             * Parses `str` which is marked up with Pango markup (see [func`Pango`.parse_markup]),
             * setting the label’s text and attribute list based on the parse results.
             * If characters in `str` are preceded by an underscore, they are underlined
             * indicating that they represent a keyboard accelerator called a mnemonic.
             *
             * The mnemonic key can be used to activate another widget, chosen
             * automatically, or explicitly using [method`Gtk`.Label.set_mnemonic_widget].
             * @param str a markup string
             */
            set_markup_with_mnemonic(str: string): void;
            /**
             * Sets the desired maximum width in characters of `label` to `n_chars`.
             * @param n_chars the new desired maximum width, in characters.
             */
            set_max_width_chars(n_chars: number): void;
            /**
             * Associate the label with its mnemonic target.
             *
             * If the label has been set so that it has a mnemonic key (using
             * i.e. [method`Gtk`.Label.set_markup_with_mnemonic],
             * [method`Gtk`.Label.set_text_with_mnemonic],
             * [ctor`Gtk`.Label.new_with_mnemonic]
             * or the [property`Gtk`.Label:use_underline] property) the label can be
             * associated with a widget that is the target of the mnemonic. When the
             * label is inside a widget (like a [class`Gtk`.Button] or a
             * [class`Gtk`.Notebook] tab) it is automatically associated with the correct
             * widget, but sometimes (i.e. when the target is a [class`Gtk`.Entry] next to
             * the label) you need to set it explicitly using this function.
             *
             * The target widget will be accelerated by emitting the
             * [signal`Gtk`.Widget::mnemonic-activate] signal on it. The default handler for
             * this signal will activate the widget if there are no mnemonic collisions
             * and toggle focus between the colliding widgets otherwise.
             * @param widget the target `GtkWidget`, or %NULL to unset
             */
            set_mnemonic_widget(widget?: Widget | null): void;
            /**
             * Select the line wrapping for the natural size request.
             *
             * This only affects the natural size requested, for the actual wrapping used,
             * see the [property`Gtk`.Label:wrap-mode] property.
             * @param wrap_mode the line wrapping mode
             */
            set_natural_wrap_mode(wrap_mode: NaturalWrapMode | null): void;
            /**
             * Makes text in the label selectable.
             *
             * Selectable labels allow the user to select text from the label,
             * for copy-and-paste.
             * @param setting %TRUE to allow selecting text in the label
             */
            set_selectable(setting: boolean): void;
            /**
             * Sets whether the label is in single line mode.
             * @param single_line_mode %TRUE if the label should be in single line mode
             */
            set_single_line_mode(single_line_mode: boolean): void;
            /**
             * Sets the default tab stops for paragraphs in `self`.
             * @param tabs tabs as a `PangoTabArray`
             */
            set_tabs(tabs?: Pango.TabArray | null): void;
            /**
             * Sets the text within the `GtkLabel` widget.
             *
             * It overwrites any text that was there before.
             *
             * This function will clear any previously set mnemonic accelerators,
             * and set the [property`Gtk`.Label:use-underline] property to %FALSE as
             * a side effect.
             *
             * This function will set the [property`Gtk`.Label:use-markup] property
             * to %FALSE as a side effect.
             *
             * See also: [method`Gtk`.Label.set_markup]
             * @param str The text you want to set
             */
            set_text(str: string): void;
            /**
             * Sets the label’s text from the string `str`.
             *
             * If characters in `str` are preceded by an underscore, they are underlined
             * indicating that they represent a keyboard accelerator called a mnemonic.
             * The mnemonic key can be used to activate another widget, chosen
             * automatically, or explicitly using [method`Gtk`.Label.set_mnemonic_widget].
             * @param str a string
             */
            set_text_with_mnemonic(str: string): void;
            /**
             * Sets whether the text of the label contains markup.
             *
             * See [method`Gtk`.Label.set_markup].
             * @param setting %TRUE if the label’s text should be parsed for markup.
             */
            set_use_markup(setting: boolean): void;
            /**
             * Sets whether underlines in the text indicate mnemonics.
             * @param setting %TRUE if underlines in the text indicate mnemonics
             */
            set_use_underline(setting: boolean): void;
            /**
             * Sets the desired width in characters of `label` to `n_chars`.
             * @param n_chars the new desired width, in characters.
             */
            set_width_chars(n_chars: number): void;
            /**
             * Toggles line wrapping within the `GtkLabel` widget.
             *
             * %TRUE makes it break lines if text exceeds the widget’s size.
             * %FALSE lets the text get cut off by the edge of the widget if
             * it exceeds the widget size.
             *
             * Note that setting line wrapping to %TRUE does not make the label
             * wrap at its parent container’s width, because GTK widgets
             * conceptually can’t make their requisition depend on the parent
             * container’s size. For a label that wraps at a specific position,
             * set the label’s width using [method`Gtk`.Widget.set_size_request].
             * @param wrap the setting
             */
            set_wrap(wrap: boolean): void;
            /**
             * Controls how line wrapping is done.
             *
             * This only affects the label if line wrapping is on. (See
             * [method`Gtk`.Label.set_wrap]) The default is %PANGO_WRAP_WORD
             * which means wrap on word boundaries.
             *
             * For sizing behavior, also consider the [property`Gtk`.Label:natural-wrap-mode]
             * property.
             * @param wrap_mode the line wrapping mode
             */
            set_wrap_mode(wrap_mode: Pango.WrapMode | null): void;
            /**
             * Sets the `xalign` of the label.
             *
             * See the [property`Gtk`.Label:xalign] property.
             * @param xalign the new xalign value, between 0 and 1
             */
            set_xalign(xalign: number): void;
            /**
             * Sets the `yalign` of the label.
             *
             * See the [property`Gtk`.Label:yalign] property.
             * @param yalign the new yalign value, between 0 and 1
             */
            set_yalign(yalign: number): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Updates the position of the caret.
             *
             * Implementations of the `GtkAccessibleText` interface should call this
             * function every time the caret has moved, in order to notify assistive
             * technologies.
             */
            update_caret_position(): void;
            /**
             * Notifies assistive technologies of a change in contents.
             *
             * Implementations of the `GtkAccessibleText` interface should call this
             * function every time their contents change as the result of an operation,
             * like an insertion or a removal.
             *
             * Note: If the change is a deletion, this function must be called *before*
             * removing the contents, if it is an insertion, it must be called *after*
             * inserting the new contents.
             * @param change the type of change in the contents
             * @param start the starting offset of the change, in characters
             * @param end the end offset of the change, in characters
             */
            update_contents(change: AccessibleTextContentChange | null, start: number, end: number): void;
            /**
             * Updates the boundary of the selection.
             *
             * Implementations of the `GtkAccessibleText` interface should call this
             * function every time the selection has moved, in order to notify assistive
             * technologies.
             */
            update_selection_bound(): void;
            /**
             * Retrieves the text attributes inside the accessible object.
             *
             * Each attribute is composed by:
             *
             * - a range
             * - a name
             * - a value
             *
             * It is left to the implementation to determine the serialization format
             * of the value to a string.
             *
             * GTK provides support for various text attribute names and values, but
             * implementations of this interface are free to add their own attributes.
             *
             * If this function returns true, `n_ranges` will be set to a value
             * greater than or equal to one, `ranges` will be set to a newly
             * allocated array of [struct#Gtk.AccessibleTextRange].
             * @param offset the offset, in characters
             */
            vfunc_get_attributes(
                offset: number,
            ): [boolean, AccessibleTextRange[] | null, string[] | null, string[] | null];
            /**
             * Retrieves the position of the caret inside the accessible object.
             */
            vfunc_get_caret_position(): number;
            /**
             * Retrieve the current contents of the accessible object within
             * the given range.
             *
             * If `end` is `G_MAXUINT`, the end of the range is the full content
             * of the accessible object.
             * @param start the beginning of the range, in characters
             * @param end the end of the range, in characters
             */
            vfunc_get_contents(start: number, end: number): GLib.Bytes;
            /**
             * Retrieve the current contents of the accessible object starting
             * from the given offset, and using the given granularity.
             *
             * The `start` and `end` values contain the boundaries of the text.
             * @param offset the offset, in characters
             * @param granularity the granularity of the query
             */
            vfunc_get_contents_at(offset: number, granularity: AccessibleTextGranularity): [GLib.Bytes, number, number];
            /**
             * Retrieves the default text attributes inside the accessible object.
             *
             * Each attribute is composed by:
             *
             * - a name
             * - a value
             *
             * It is left to the implementation to determine the serialization format
             * of the value to a string.
             *
             * GTK provides support for various text attribute names and values, but
             * implementations of this interface are free to add their own attributes.
             */
            vfunc_get_default_attributes(): [string[] | null, string[] | null];
            /**
             * Obtains the extents of a range of text, in widget coordinates.
             * @param start the start offset, in characters
             * @param end the end offset, in characters, @extents (out caller-allocates): return location for the extents
             * @param extents
             */
            vfunc_get_extents(start: number, end: number, extents: Graphene.Rect): boolean;
            /**
             * Gets the text offset at a given point.
             * @param point a point in widget coordinates of @self
             */
            vfunc_get_offset(point: Graphene.Point): [boolean, number];
            /**
             * Retrieves the selection ranges in the accessible object.
             *
             * If this function returns true, `n_ranges` will be set to a value
             * greater than or equal to one, and `ranges` will be set to a newly
             * allocated array of [struct#Gtk.AccessibleTextRange].
             */
            vfunc_get_selection(): [boolean, AccessibleTextRange[] | null];
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace LayoutChild {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                child_widget: Widget;
                childWidget: Widget;
                layout_manager: LayoutManager;
                layoutManager: LayoutManager;
            }
        }

        /**
         * `GtkLayoutChild` is the base class for objects that are meant to hold
         * layout properties.
         *
         * If a `GtkLayoutManager` has per-child properties, like their packing type,
         * or the horizontal and vertical span, or the icon name, then the layout
         * manager should use a `GtkLayoutChild` implementation to store those properties.
         *
         * A `GtkLayoutChild` instance is only ever valid while a widget is part
         * of a layout.
         */
        abstract class LayoutChild extends GObject.Object {
            static $gtype: GObject.GType<LayoutChild>;

            // Properties

            /**
             * The widget that is associated to the `GtkLayoutChild` instance.
             */
            get child_widget(): Widget;
            /**
             * The widget that is associated to the `GtkLayoutChild` instance.
             */
            get childWidget(): Widget;
            /**
             * The layout manager that created the `GtkLayoutChild` instance.
             */
            get layout_manager(): LayoutManager;
            /**
             * The layout manager that created the `GtkLayoutChild` instance.
             */
            get layoutManager(): LayoutManager;

            // Constructors

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

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

            // Methods

            /**
             * Retrieves the `GtkWidget` associated to the given `layout_child`.
             * @returns a `GtkWidget`
             */
            get_child_widget(): Widget;
            /**
             * Retrieves the `GtkLayoutManager` instance that created the
             * given `layout_child`.
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager;
        }

        namespace LayoutManager {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * Layout managers are delegate classes that handle the preferred size
         * and the allocation of a widget.
         *
         * You typically subclass `GtkLayoutManager` if you want to implement a
         * layout policy for the children of a widget, or if you want to determine
         * the size of a widget depending on its contents.
         *
         * Each `GtkWidget` can only have a `GtkLayoutManager` instance associated
         * to it at any given time; it is possible, though, to replace the layout
         * manager instance using [method`Gtk`.Widget.set_layout_manager].
         *
         * ## Layout properties
         *
         * A layout manager can expose properties for controlling the layout of
         * each child, by creating an object type derived from [class`Gtk`.LayoutChild]
         * and installing the properties on it as normal `GObject` properties.
         *
         * Each `GtkLayoutChild` instance storing the layout properties for a
         * specific child is created through the [method`Gtk`.LayoutManager.get_layout_child]
         * method; a `GtkLayoutManager` controls the creation of its `GtkLayoutChild`
         * instances by overriding the GtkLayoutManagerClass.create_layout_child()
         * virtual function. The typical implementation should look like:
         *
         * ```c
         * static GtkLayoutChild *
         * create_layout_child (GtkLayoutManager *manager,
         *                      GtkWidget        *container,
         *                      GtkWidget        *child)
         * {
         *   return g_object_new (your_layout_child_get_type (),
         *                        "layout-manager", manager,
         *                        "child-widget", child,
         *                        NULL);
         * }
         * ```
         *
         * The [property`Gtk`.LayoutChild:layout-manager] and
         * [property`Gtk`.LayoutChild:child-widget] properties
         * on the newly created `GtkLayoutChild` instance are mandatory. The
         * `GtkLayoutManager` will cache the newly created `GtkLayoutChild` instance
         * until the widget is removed from its parent, or the parent removes the
         * layout manager.
         *
         * Each `GtkLayoutManager` instance creating a `GtkLayoutChild` should use
         * [method`Gtk`.LayoutManager.get_layout_child] every time it needs to query
         * the layout properties; each `GtkLayoutChild` instance should call
         * [method`Gtk`.LayoutManager.layout_changed] every time a property is
         * updated, in order to queue a new size measuring and allocation.
         */
        abstract class LayoutManager extends GObject.Object {
            static $gtype: GObject.GType<LayoutManager>;

            // Constructors

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

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

            // Virtual methods

            /**
             * Assigns the given `width,` `height,` and `baseline` to
             * a `widget,` and computes the position and sizes of the children of
             * the `widget` using the layout management policy of `manager`.
             * @param widget the `GtkWidget` using @manager
             * @param width the new width of the @widget
             * @param height the new height of the @widget
             * @param baseline the baseline position of the @widget, or -1
             */
            vfunc_allocate(widget: Widget, width: number, height: number, baseline: number): void;
            /**
             * Create a `GtkLayoutChild` instance for the given `for_child` widget.
             * @param widget the widget using the @manager
             * @param for_child the child of @widget
             */
            vfunc_create_layout_child(widget: Widget, for_child: Widget): LayoutChild;
            /**
             * a virtual function, used to return the preferred
             *   request mode for the layout manager; for instance, "width for height"
             *   or "height for width"; see `GtkSizeRequestMode`
             * @param widget
             */
            vfunc_get_request_mode(widget: Widget): SizeRequestMode;
            /**
             * Measures the size of the `widget` using `manager,` for the
             * given `orientation` and size.
             *
             * See the [class`Gtk`.Widget] documentation on layout management for
             * more details.
             * @param widget the `GtkWidget` using @manager
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation; for instance, if   the @orientation is %GTK_ORIENTATION_HORIZONTAL, this is the height   of the widget; if the @orientation is %GTK_ORIENTATION_VERTICAL, this   is the width of the widget. This allows to measure the height for the   given width, and the width for the given height. Use -1 if the size   is not known
             */
            vfunc_measure(widget: Widget, orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * a virtual function, called when the widget using the layout
             *   manager is attached to a `GtkRoot`
             */
            vfunc_root(): void;
            /**
             * a virtual function, called when the widget using the layout
             *   manager is detached from a `GtkRoot`
             */
            vfunc_unroot(): void;

            // Methods

            /**
             * Assigns the given `width,` `height,` and `baseline` to
             * a `widget,` and computes the position and sizes of the children of
             * the `widget` using the layout management policy of `manager`.
             * @param widget the `GtkWidget` using @manager
             * @param width the new width of the @widget
             * @param height the new height of the @widget
             * @param baseline the baseline position of the @widget, or -1
             */
            allocate(widget: Widget, width: number, height: number, baseline: number): void;
            /**
             * Retrieves a `GtkLayoutChild` instance for the `GtkLayoutManager`,
             * creating one if necessary.
             *
             * The `child` widget must be a child of the widget using `manager`.
             *
             * The `GtkLayoutChild` instance is owned by the `GtkLayoutManager`,
             * and is guaranteed to exist as long as `child` is a child of the
             * `GtkWidget` using the given `GtkLayoutManager`.
             * @param child a `GtkWidget`
             * @returns a `GtkLayoutChild`
             */
            get_layout_child(child: Widget): LayoutChild;
            /**
             * Retrieves the request mode of `manager`.
             * @returns a `GtkSizeRequestMode`
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Retrieves the `GtkWidget` using the given `GtkLayoutManager`.
             * @returns a `GtkWidget`
             */
            get_widget(): Widget | null;
            /**
             * Queues a resize on the `GtkWidget` using `manager,` if any.
             *
             * This function should be called by subclasses of `GtkLayoutManager`
             * in response to changes to their layout management policies.
             */
            layout_changed(): void;
            /**
             * Measures the size of the `widget` using `manager,` for the
             * given `orientation` and size.
             *
             * See the [class`Gtk`.Widget] documentation on layout management for
             * more details.
             * @param widget the `GtkWidget` using @manager
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation; for instance, if   the @orientation is %GTK_ORIENTATION_HORIZONTAL, this is the height   of the widget; if the @orientation is %GTK_ORIENTATION_VERTICAL, this   is the width of the widget. This allows to measure the height for the   given width, and the width for the given height. Use -1 if the size   is not known
             */
            measure(
                widget: Widget,
                orientation: Orientation | null,
                for_size: number,
            ): [number, number, number, number];
        }

        namespace LevelBar {
            // Signal callback interfaces

            interface OffsetChanged {
                (name: string): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    AccessibleRange.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Orientable.ConstructorProps {
                inverted: boolean;
                max_value: number;
                maxValue: number;
                min_value: number;
                minValue: number;
                mode: LevelBarMode;
                value: number;
            }
        }

        /**
         * `GtkLevelBar` is a widget that can be used as a level indicator.
         *
         * Typical use cases are displaying the strength of a password, or
         * showing the charge level of a battery.
         *
         * ![An example GtkLevelBar](levelbar.png)
         *
         * Use [method`Gtk`.LevelBar.set_value] to set the current value, and
         * [method`Gtk`.LevelBar.add_offset_value] to set the value offsets at which
         * the bar will be considered in a different state. GTK will add a few
         * offsets by default on the level bar: %GTK_LEVEL_BAR_OFFSET_LOW,
         * %GTK_LEVEL_BAR_OFFSET_HIGH and %GTK_LEVEL_BAR_OFFSET_FULL, with
         * values 0.25, 0.75 and 1.0 respectively.
         *
         * Note that it is your responsibility to update preexisting offsets
         * when changing the minimum or maximum value. GTK will simply clamp
         * them to the new range.
         *
         * ## Adding a custom offset on the bar
         *
         * ```c
         * static GtkWidget *
         * create_level_bar (void)
         * {
         *   GtkWidget *widget;
         *   GtkLevelBar *bar;
         *
         *   widget = gtk_level_bar_new ();
         *   bar = GTK_LEVEL_BAR (widget);
         *
         *   // This changes the value of the default low offset
         *
         *   gtk_level_bar_add_offset_value (bar,
         *                                   GTK_LEVEL_BAR_OFFSET_LOW,
         *                                   0.10);
         *
         *   // This adds a new offset to the bar; the application will
         *   // be able to change its color CSS like this:
         *   //
         *   // levelbar block.my-offset {
         *   //   background-color: magenta;
         *   //   border-style: solid;
         *   //   border-color: black;
         *   //   border-width: 1px;
         *   // }
         *
         *   gtk_level_bar_add_offset_value (bar, "my-offset", 0.60);
         *
         *   return widget;
         * }
         * ```
         *
         * The default interval of values is between zero and one, but it’s possible
         * to modify the interval using [method`Gtk`.LevelBar.set_min_value] and
         * [method`Gtk`.LevelBar.set_max_value]. The value will be always drawn in
         * proportion to the admissible interval, i.e. a value of 15 with a specified
         * interval between 10 and 20 is equivalent to a value of 0.5 with an interval
         * between 0 and 1. When %GTK_LEVEL_BAR_MODE_DISCRETE is used, the bar level
         * is rendered as a finite number of separated blocks instead of a single one.
         * The number of blocks that will be rendered is equal to the number of units
         * specified by the admissible interval.
         *
         * For instance, to build a bar rendered with five blocks, it’s sufficient to
         * set the minimum value to 0 and the maximum value to 5 after changing the
         * indicator mode to discrete.
         *
         * # GtkLevelBar as GtkBuildable
         *
         * The `GtkLevelBar` implementation of the `GtkBuildable` interface supports a
         * custom `<offsets>` element, which can contain any number of `<offset>` elements,
         * each of which must have "name" and "value" attributes.
         *
         * # CSS nodes
         *
         * ```
         * levelbar[.discrete]
         * ╰── trough
         *     ├── block.filled.level-name
         *     ┊
         *     ├── block.empty
         *     ┊
         * ```
         *
         * `GtkLevelBar` has a main CSS node with name levelbar and one of the style
         * classes .discrete or .continuous and a subnode with name trough. Below the
         * trough node are a number of nodes with name block and style class .filled
         * or .empty. In continuous mode, there is exactly one node of each, in discrete
         * mode, the number of filled and unfilled nodes corresponds to blocks that are
         * drawn. The block.filled nodes also get a style class .level-name corresponding
         * to the level for the current value.
         *
         * In horizontal orientation, the nodes are always arranged from left to right,
         * regardless of text direction.
         *
         * # Accessibility
         *
         * `GtkLevelBar` uses the %GTK_ACCESSIBLE_ROLE_METER role.
         */
        class LevelBar extends Widget implements Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable {
            static $gtype: GObject.GType<LevelBar>;

            // Properties

            /**
             * Whether the `GtkLeveBar` is inverted.
             *
             * Level bars normally grow from top to bottom or left to right.
             * Inverted level bars grow in the opposite direction.
             */
            get inverted(): boolean;
            set inverted(val: boolean);
            /**
             * Determines the maximum value of the interval that can be displayed by the bar.
             */
            get max_value(): number;
            set max_value(val: number);
            /**
             * Determines the maximum value of the interval that can be displayed by the bar.
             */
            get maxValue(): number;
            set maxValue(val: number);
            /**
             * Determines the minimum value of the interval that can be displayed by the bar.
             */
            get min_value(): number;
            set min_value(val: number);
            /**
             * Determines the minimum value of the interval that can be displayed by the bar.
             */
            get minValue(): number;
            set minValue(val: number);
            /**
             * Determines the way `GtkLevelBar` interprets the value properties to draw the
             * level fill area.
             *
             * Specifically, when the value is %GTK_LEVEL_BAR_MODE_CONTINUOUS,
             * `GtkLevelBar` will draw a single block representing the current value in
             * that area; when the value is %GTK_LEVEL_BAR_MODE_DISCRETE,
             * the widget will draw a succession of separate blocks filling the
             * draw area, with the number of blocks being equal to the units separating
             * the integral roundings of [property`Gtk`.LevelBar:min-value] and
             * [property`Gtk`.LevelBar:max-value].
             */
            get mode(): LevelBarMode;
            set mode(val: LevelBarMode);
            /**
             * Determines the currently filled value of the level bar.
             */
            get value(): number;
            set value(val: number);

            // Constructors

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

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

            static ['new'](): LevelBar;

            static new_for_interval(min_value: number, max_value: number): LevelBar;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'offset-changed', callback: (_source: this, name: string) => void): number;
            connect_after(signal: 'offset-changed', callback: (_source: this, name: string) => void): number;
            emit(signal: 'offset-changed', name: string): void;

            // Methods

            /**
             * Adds a new offset marker on `self` at the position specified by `value`.
             *
             * When the bar value is in the interval topped by `value` (or between `value`
             * and [property`Gtk`.LevelBar:max-value] in case the offset is the last one
             * on the bar) a style class named `level-``name` will be applied
             * when rendering the level bar fill.
             *
             * If another offset marker named `name` exists, its value will be
             * replaced by `value`.
             * @param name the name of the new offset
             * @param value the value for the new offset
             */
            add_offset_value(name: string, value: number): void;
            /**
             * Returns whether the levelbar is inverted.
             * @returns %TRUE if the level bar is inverted
             */
            get_inverted(): boolean;
            /**
             * Returns the `max-value` of the `GtkLevelBar`.
             * @returns a positive value
             */
            get_max_value(): number;
            /**
             * Returns the `min-value` of the `GtkLevelBar`.
             * @returns a positive value
             */
            get_min_value(): number;
            /**
             * Returns the `mode` of the `GtkLevelBar`.
             * @returns a `GtkLevelBarMode`
             */
            get_mode(): LevelBarMode;
            /**
             * Fetches the value specified for the offset marker `name` in `self`.
             * @param name the name of an offset in the bar
             * @returns %TRUE if the specified offset is found
             */
            get_offset_value(name: string | null): [boolean, number];
            /**
             * Returns the `value` of the `GtkLevelBar`.
             * @returns a value in the interval between   [property@Gtk.LevelBar:min-value] and [property@Gtk.LevelBar:max-value]
             */
            get_value(): number;
            /**
             * Removes an offset marker from a `GtkLevelBar`.
             *
             * The marker must have been previously added with
             * [method`Gtk`.LevelBar.add_offset_value].
             * @param name the name of an offset in the bar
             */
            remove_offset_value(name?: string | null): void;
            /**
             * Sets whether the `GtkLevelBar` is inverted.
             * @param inverted %TRUE to invert the level bar
             */
            set_inverted(inverted: boolean): void;
            /**
             * Sets the `max-value` of the `GtkLevelBar`.
             *
             * You probably want to update preexisting level offsets after calling
             * this function.
             * @param value a positive value
             */
            set_max_value(value: number): void;
            /**
             * Sets the `min-value` of the `GtkLevelBar`.
             *
             * You probably want to update preexisting level offsets after calling
             * this function.
             * @param value a positive value
             */
            set_min_value(value: number): void;
            /**
             * Sets the `mode` of the `GtkLevelBar`.
             * @param mode a `GtkLevelBarMode`
             */
            set_mode(mode: LevelBarMode | null): void;
            /**
             * Sets the value of the `GtkLevelBar`.
             * @param value a value in the interval between   [property@Gtk.LevelBar:min-value] and [property@Gtk.LevelBar:max-value]
             */
            set_value(value: number): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Sets the current value of the accessible range.
             *
             * This operation should behave similarly as if the user performed the
             * action.
             * @param value the value to set
             */
            vfunc_set_current_value(value: number): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace LinkButton {
            // Signal callback interfaces

            interface ActivateLink {
                (): boolean;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Button.ConstructorProps,
                    Accessible.ConstructorProps,
                    Actionable.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                uri: string;
                visited: boolean;
            }
        }

        /**
         * A `GtkLinkButton` is a button with a hyperlink.
         *
         * ![An example GtkLinkButton](link-button.png)
         *
         * It is useful to show quick links to resources.
         *
         * A link button is created by calling either [ctor`Gtk`.LinkButton.new] or
         * [ctor`Gtk`.LinkButton.new_with_label]. If using the former, the URI you
         * pass to the constructor is used as a label for the widget.
         *
         * The URI bound to a `GtkLinkButton` can be set specifically using
         * [method`Gtk`.LinkButton.set_uri].
         *
         * By default, `GtkLinkButton` calls [method`Gtk`.FileLauncher.launch] when the button
         * is clicked. This behaviour can be overridden by connecting to the
         * [signal`Gtk`.LinkButton::activate-link] signal and returning %TRUE from
         * the signal handler.
         *
         * # Shortcuts and Gestures
         *
         * `GtkLinkButton` supports the following keyboard shortcuts:
         *
         * - <kbd>Shift</kbd>+<kbd>F10</kbd> or <kbd>Menu</kbd> opens the context menu.
         *
         * # Actions
         *
         * `GtkLinkButton` defines a set of built-in actions:
         *
         * - `clipboard.copy` copies the url to the clipboard.
         * - `menu.popup` opens the context menu.
         *
         * # CSS nodes
         *
         * `GtkLinkButton` has a single CSS node with name button. To differentiate
         * it from a plain `GtkButton`, it gets the .link style class.
         *
         * # Accessibility
         *
         * `GtkLinkButton` uses the %GTK_ACCESSIBLE_ROLE_LINK role.
         */
        class LinkButton extends Button implements Accessible, Actionable, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<LinkButton>;

            // Properties

            /**
             * The URI bound to this button.
             */
            get uri(): string;
            set uri(val: string);
            /**
             * The 'visited' state of this button.
             *
             * A visited link is drawn in a different color.
             */
            get visited(): boolean;
            set visited(val: boolean);

            // Constructors

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

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

            static ['new'](uri: string): LinkButton;
            // Conflicted with Gtk.Button.new

            static ['new'](...args: never[]): any;

            static new_with_label(uri: string, label?: string | null): LinkButton;
            // Conflicted with Gtk.Button.new_with_label

            static new_with_label(...args: never[]): any;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate-link', callback: (_source: this) => boolean): number;
            connect_after(signal: 'activate-link', callback: (_source: this) => boolean): number;
            emit(signal: 'activate-link'): void;

            // Methods

            /**
             * Retrieves the URI of the `GtkLinkButton`.
             * @returns a valid URI. The returned string is owned by the link button   and should not be modified or freed.
             */
            get_uri(): string;
            /**
             * Retrieves the “visited” state of the `GtkLinkButton`.
             *
             * The button becomes visited when it is clicked. If the URI
             * is changed on the button, the “visited” state is unset again.
             *
             * The state may also be changed using [method`Gtk`.LinkButton.set_visited].
             * @returns %TRUE if the link has been visited, %FALSE otherwise
             */
            get_visited(): boolean;
            /**
             * Sets `uri` as the URI where the `GtkLinkButton` points.
             *
             * As a side-effect this unsets the “visited” state of the button.
             * @param uri a valid URI
             */
            set_uri(uri: string): void;
            /**
             * Sets the “visited” state of the `GtkLinkButton`.
             *
             * See [method`Gtk`.LinkButton.get_visited] for more details.
             * @param visited the new “visited” state
             */
            set_visited(visited: boolean): void;

            // Inherited properties
            /**
             * The name of the action with which this widget should be associated.
             */
            get action_name(): string;
            set action_name(val: string);
            /**
             * The name of the action with which this widget should be associated.
             */
            get actionName(): string;
            set actionName(val: string);
            /**
             * The target value of the actionable widget's action.
             */
            get action_target(): GLib.Variant;
            set action_target(val: GLib.Variant);
            /**
             * The target value of the actionable widget's action.
             */
            get actionTarget(): GLib.Variant;
            set actionTarget(val: GLib.Variant);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Gets the action name for `actionable`.
             * @returns the action name
             */
            get_action_name(): string | null;
            /**
             * Gets the current target value of `actionable`.
             * @returns the current target value
             */
            get_action_target_value(): GLib.Variant | null;
            /**
             * Specifies the name of the action with which this widget should be
             * associated.
             *
             * If `action_name` is %NULL then the widget will be unassociated from
             * any previous action.
             *
             * Usually this function is used when the widget is located (or will be
             * located) within the hierarchy of a `GtkApplicationWindow`.
             *
             * Names are of the form “win.save” or “app.quit” for actions on the
             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
             * associated with the window.
             * @param action_name an action name
             */
            set_action_name(action_name?: string | null): void;
            /**
             * Sets the target value of an actionable widget.
             *
             * If `target_value` is %NULL then the target value is unset.
             *
             * The target value has two purposes. First, it is used as the parameter
             * to activation of the action associated with the `GtkActionable` widget.
             * Second, it is used to determine if the widget should be rendered as
             * “active” — the widget is active if the state is equal to the given target.
             *
             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
             * with string state in a typical “radio button” situation. Each button
             * will be associated with the same action, but with a different target
             * value for that action. Clicking on a particular button will activate
             * the action with the target of that button, which will typically cause
             * the action’s state to change to that value. Since the action’s state
             * is now equal to the target value of the button, the button will now
             * be rendered as active (and the other buttons, with different targets,
             * rendered inactive).
             * @param target_value a [struct@GLib.Variant] to set as the target value
             */
            set_action_target_value(target_value?: GLib.Variant | null): void;
            /**
             * Sets the action-name and associated string target value of an
             * actionable widget.
             *
             * `detailed_action_name` is a string in the format accepted by
             * [func`Gio`.Action.parse_detailed_name].
             * @param detailed_action_name the detailed action name
             */
            set_detailed_action_name(detailed_action_name: string): void;
            /**
             * Gets the action name for `actionable`.
             */
            vfunc_get_action_name(): string | null;
            /**
             * Gets the current target value of `actionable`.
             */
            vfunc_get_action_target_value(): GLib.Variant | null;
            /**
             * Specifies the name of the action with which this widget should be
             * associated.
             *
             * If `action_name` is %NULL then the widget will be unassociated from
             * any previous action.
             *
             * Usually this function is used when the widget is located (or will be
             * located) within the hierarchy of a `GtkApplicationWindow`.
             *
             * Names are of the form “win.save” or “app.quit” for actions on the
             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
             * associated with the window.
             * @param action_name an action name
             */
            vfunc_set_action_name(action_name?: string | null): void;
            /**
             * Sets the target value of an actionable widget.
             *
             * If `target_value` is %NULL then the target value is unset.
             *
             * The target value has two purposes. First, it is used as the parameter
             * to activation of the action associated with the `GtkActionable` widget.
             * Second, it is used to determine if the widget should be rendered as
             * “active” — the widget is active if the state is equal to the given target.
             *
             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
             * with string state in a typical “radio button” situation. Each button
             * will be associated with the same action, but with a different target
             * value for that action. Clicking on a particular button will activate
             * the action with the target of that button, which will typically cause
             * the action’s state to change to that value. Since the action’s state
             * is now equal to the target value of the button, the button will now
             * be rendered as active (and the other buttons, with different targets,
             * rendered inactive).
             * @param target_value a [struct@GLib.Variant] to set as the target value
             */
            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace ListBase {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Orientable.ConstructorProps,
                    Scrollable.ConstructorProps {
                orientation: Orientation;
            }
        }

        /**
         * `GtkListBase` is the abstract base class for GTK's list widgets.
         *
         * # Shortcuts and Gestures
         *
         * `GtkListBase` supports the following keyboard shortcuts:
         *
         * - <kbd>Ctrl</kbd>+<kbd>A</kbd> or <kbd>Ctrl</kbd>+<kbd>&sol;</kbd>
         *   selects all items.
         * - <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>A</kbd> or
         *   <kbd>Ctrl</kbd>+<kbd>&bsol;</kbd> unselects all items.
         *
         * The focused item is controlled by the navigation keys below, combined
         * with the <kbd>Ctrl</kbd> modifier to prevent moving the selection,
         * and the <kbd>Shift</kbd> modifier to extend the current selection.
         *
         * - <kbd>←</kbd>, <kbd>→</kbd>, <kbd>↑</kbd>, <kbd>↓</kbd> move the focus
         *   on the next item in the designed direction.
         * - <kbd>Home</kbd> and <kbd>End</kbd> focus the first or last item.
         * - <kbd>PgUp</kbd> and <kbd>PgDn</kbd> move the focus one page up or down.
         *
         * List item widgets support the following keyboard shortcuts:
         *
         * - <kbd>Enter</kbd> activates the item.
         * - <kbd>␣</kbd> selects the item, with the same <kbd>Ctrl</kbd> and
         *   <kbd>Shift</kbd> modifiers combinations as the navigation keys.
         *
         * # Actions
         *
         * `GtkListBase` defines a set of built-in actions:
         *
         * - `list.scroll-to-item` moves the visible area to the item at given position
         *   with the minimum amount of scrolling required. If the item is already
         *   visible, nothing happens.
         * - `list.select-item` changes the selection.
         * - `list.select-all` selects all items in the model, if the selection model
         *   supports it.
         * - `list.unselect-all` unselects all items in the model, if the selection
         *   model supports it.
         *
         * List item widgets install the following actions:
         *
         * - `listitem.select` changes selection if the item is selectable.
         * - `listitem.scroll-to` moves the visible area of the list to this item with
         *   the minimum amount of scrolling required.
         */
        abstract class ListBase
            extends Widget
            implements Accessible, Buildable, ConstraintTarget, Orientable, Scrollable
        {
            static $gtype: GObject.GType<ListBase>;

            // Properties

            /**
             * The orientation of the list. See GtkOrientable:orientation
             * for details.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Constructors

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

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

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * Horizontal `GtkAdjustment` of the scrollable widget.
             *
             * This adjustment is shared between the scrollable widget and its parent.
             */
            get hadjustment(): Adjustment;
            set hadjustment(val: Adjustment);
            /**
             * Determines when horizontal scrolling should start.
             */
            get hscroll_policy(): ScrollablePolicy;
            set hscroll_policy(val: ScrollablePolicy);
            /**
             * Determines when horizontal scrolling should start.
             */
            get hscrollPolicy(): ScrollablePolicy;
            set hscrollPolicy(val: ScrollablePolicy);
            /**
             * Vertical `GtkAdjustment` of the scrollable widget.
             *
             * This adjustment is shared between the scrollable widget and its parent.
             */
            get vadjustment(): Adjustment;
            set vadjustment(val: Adjustment);
            /**
             * Determines when vertical scrolling should start.
             */
            get vscroll_policy(): ScrollablePolicy;
            set vscroll_policy(val: ScrollablePolicy);
            /**
             * Determines when vertical scrolling should start.
             */
            get vscrollPolicy(): ScrollablePolicy;
            set vscrollPolicy(val: ScrollablePolicy);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Returns the size of a non-scrolling border around the
             * outside of the scrollable.
             *
             * An example for this would be treeview headers. GTK can use
             * this information to display overlaid graphics, like the
             * overshoot indication, at the right position.
             * @returns %TRUE if @border has been set
             */
            get_border(): [boolean, Border];
            /**
             * Retrieves the `GtkAdjustment` used for horizontal scrolling.
             * @returns horizontal `GtkAdjustment`.
             */
            get_hadjustment(): Adjustment | null;
            /**
             * Gets the horizontal `GtkScrollablePolicy`.
             * @returns The horizontal `GtkScrollablePolicy`.
             */
            get_hscroll_policy(): ScrollablePolicy;
            /**
             * Retrieves the `GtkAdjustment` used for vertical scrolling.
             * @returns vertical `GtkAdjustment`.
             */
            get_vadjustment(): Adjustment | null;
            /**
             * Gets the vertical `GtkScrollablePolicy`.
             * @returns The vertical `GtkScrollablePolicy`.
             */
            get_vscroll_policy(): ScrollablePolicy;
            /**
             * Sets the horizontal adjustment of the `GtkScrollable`.
             * @param hadjustment a `GtkAdjustment`
             */
            set_hadjustment(hadjustment?: Adjustment | null): void;
            /**
             * Sets the `GtkScrollablePolicy`.
             *
             * The policy determines whether horizontal scrolling should start
             * below the minimum width or below the natural width.
             * @param policy the horizontal `GtkScrollablePolicy`
             */
            set_hscroll_policy(policy: ScrollablePolicy | null): void;
            /**
             * Sets the vertical adjustment of the `GtkScrollable`.
             * @param vadjustment a `GtkAdjustment`
             */
            set_vadjustment(vadjustment?: Adjustment | null): void;
            /**
             * Sets the `GtkScrollablePolicy`.
             *
             * The policy determines whether vertical scrolling should start
             * below the minimum height or below the natural height.
             * @param policy the vertical `GtkScrollablePolicy`
             */
            set_vscroll_policy(policy: ScrollablePolicy | null): void;
            /**
             * Returns the size of a non-scrolling border around the
             * outside of the scrollable.
             *
             * An example for this would be treeview headers. GTK can use
             * this information to display overlaid graphics, like the
             * overshoot indication, at the right position.
             */
            vfunc_get_border(): [boolean, Border];
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ListBox {
            // Signal callback interfaces

            interface ActivateCursorRow {
                (): void;
            }

            interface MoveCursor {
                (step: MovementStep, count: number, extend: boolean, modify: boolean): void;
            }

            interface RowActivated {
                (row: ListBoxRow): void;
            }

            interface RowSelected {
                (row?: ListBoxRow | null): void;
            }

            interface SelectAll {
                (): void;
            }

            interface SelectedRowsChanged {
                (): void;
            }

            interface ToggleCursorRow {
                (): void;
            }

            interface UnselectAll {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                accept_unpaired_release: boolean;
                acceptUnpairedRelease: boolean;
                activate_on_single_click: boolean;
                activateOnSingleClick: boolean;
                selection_mode: SelectionMode;
                selectionMode: SelectionMode;
                show_separators: boolean;
                showSeparators: boolean;
            }
        }

        /**
         * `GtkListBox` is a vertical list.
         *
         * A `GtkListBox` only contains `GtkListBoxRow` children. These rows can
         * by dynamically sorted and filtered, and headers can be added dynamically
         * depending on the row content. It also allows keyboard and mouse navigation
         * and selection like a typical list.
         *
         * Using `GtkListBox` is often an alternative to `GtkTreeView`, especially
         * when the list contents has a more complicated layout than what is allowed
         * by a `GtkCellRenderer`, or when the contents is interactive (i.e. has a
         * button in it).
         *
         * Although a `GtkListBox` must have only `GtkListBoxRow` children, you can
         * add any kind of widget to it via [method`Gtk`.ListBox.prepend],
         * [method`Gtk`.ListBox.append] and [method`Gtk`.ListBox.insert] and a
         * `GtkListBoxRow` widget will automatically be inserted between the list
         * and the widget.
         *
         * `GtkListBoxRows` can be marked as activatable or selectable. If a row is
         * activatable, [signal`Gtk`.ListBox::row-activated] will be emitted for it when
         * the user tries to activate it. If it is selectable, the row will be marked
         * as selected when the user tries to select it.
         *
         * # GtkListBox as GtkBuildable
         *
         * The `GtkListBox` implementation of the `GtkBuildable` interface supports
         * setting a child as the placeholder by specifying “placeholder” as the “type”
         * attribute of a `<child>` element. See [method`Gtk`.ListBox.set_placeholder]
         * for info.
         *
         * # Shortcuts and Gestures
         *
         * The following signals have default keybindings:
         *
         * - [signal`Gtk`.ListBox::move-cursor]
         * - [signal`Gtk`.ListBox::select-all]
         * - [signal`Gtk`.ListBox::toggle-cursor-row]
         * - [signal`Gtk`.ListBox::unselect-all]
         *
         * # CSS nodes
         *
         *
         * ```<!-- language="plain" -->
         * list[.separators][.rich-list][.navigation-sidebar][.boxed-list]
         * ╰── row[.activatable]
         * ```
         *
         *
         * `GtkListBox` uses a single CSS node named list. It may carry the .separators
         * style class, when the [property`Gtk`.ListBox:show-separators] property is set.
         * Each `GtkListBoxRow` uses a single CSS node named row. The row nodes get the
         * .activatable style class added when appropriate.
         *
         * It may also carry the .boxed-list style class. In this case, the list will be
         * automatically surrounded by a frame and have separators.
         *
         * The main list node may also carry style classes to select
         * the style of [list presentation](section-list-widget.html#list-styles):
         * .rich-list, .navigation-sidebar or .data-table.
         *
         * # Accessibility
         *
         * `GtkListBox` uses the %GTK_ACCESSIBLE_ROLE_LIST role and `GtkListBoxRow` uses
         * the %GTK_ACCESSIBLE_ROLE_LIST_ITEM role.
         */
        class ListBox extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<ListBox>;

            // Properties

            /**
             * Whether to accept unpaired release events.
             */
            get accept_unpaired_release(): boolean;
            set accept_unpaired_release(val: boolean);
            /**
             * Whether to accept unpaired release events.
             */
            get acceptUnpairedRelease(): boolean;
            set acceptUnpairedRelease(val: boolean);
            /**
             * Determines whether children can be activated with a single
             * click, or require a double-click.
             */
            get activate_on_single_click(): boolean;
            set activate_on_single_click(val: boolean);
            /**
             * Determines whether children can be activated with a single
             * click, or require a double-click.
             */
            get activateOnSingleClick(): boolean;
            set activateOnSingleClick(val: boolean);
            /**
             * The selection mode used by the list box.
             */
            get selection_mode(): SelectionMode;
            set selection_mode(val: SelectionMode);
            /**
             * The selection mode used by the list box.
             */
            get selectionMode(): SelectionMode;
            set selectionMode(val: SelectionMode);
            /**
             * Whether to show separators between rows.
             */
            get show_separators(): boolean;
            set show_separators(val: boolean);
            /**
             * Whether to show separators between rows.
             */
            get showSeparators(): boolean;
            set showSeparators(val: boolean);

            // Constructors

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

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

            static ['new'](): ListBox;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate-cursor-row', callback: (_source: this) => void): number;
            connect_after(signal: 'activate-cursor-row', callback: (_source: this) => void): number;
            emit(signal: 'activate-cursor-row'): void;
            connect(
                signal: 'move-cursor',
                callback: (_source: this, step: MovementStep, count: number, extend: boolean, modify: boolean) => void,
            ): number;
            connect_after(
                signal: 'move-cursor',
                callback: (_source: this, step: MovementStep, count: number, extend: boolean, modify: boolean) => void,
            ): number;
            emit(signal: 'move-cursor', step: MovementStep, count: number, extend: boolean, modify: boolean): void;
            connect(signal: 'row-activated', callback: (_source: this, row: ListBoxRow) => void): number;
            connect_after(signal: 'row-activated', callback: (_source: this, row: ListBoxRow) => void): number;
            emit(signal: 'row-activated', row: ListBoxRow): void;
            connect(signal: 'row-selected', callback: (_source: this, row: ListBoxRow | null) => void): number;
            connect_after(signal: 'row-selected', callback: (_source: this, row: ListBoxRow | null) => void): number;
            emit(signal: 'row-selected', row?: ListBoxRow | null): void;
            connect(signal: 'select-all', callback: (_source: this) => void): number;
            connect_after(signal: 'select-all', callback: (_source: this) => void): number;
            emit(signal: 'select-all'): void;
            connect(signal: 'selected-rows-changed', callback: (_source: this) => void): number;
            connect_after(signal: 'selected-rows-changed', callback: (_source: this) => void): number;
            emit(signal: 'selected-rows-changed'): void;
            connect(signal: 'toggle-cursor-row', callback: (_source: this) => void): number;
            connect_after(signal: 'toggle-cursor-row', callback: (_source: this) => void): number;
            emit(signal: 'toggle-cursor-row'): void;
            connect(signal: 'unselect-all', callback: (_source: this) => void): number;
            connect_after(signal: 'unselect-all', callback: (_source: this) => void): number;
            emit(signal: 'unselect-all'): void;

            // Methods

            /**
             * Append a widget to the list.
             *
             * If a sort function is set, the widget will
             * actually be inserted at the calculated position.
             * @param child the `GtkWidget` to add
             */
            append(child: Widget): void;
            /**
             * Binds `model` to `box`.
             *
             * If `box` was already bound to a model, that previous binding is
             * destroyed.
             *
             * The contents of `box` are cleared and then filled with widgets that
             * represent items from `model`. `box` is updated whenever `model` changes.
             * If `model` is %NULL, `box` is left empty.
             *
             * It is undefined to add or remove widgets directly (for example, with
             * [method`Gtk`.ListBox.insert]) while `box` is bound to a model.
             *
             * Note that using a model is incompatible with the filtering and sorting
             * functionality in `GtkListBox`. When using a model, filtering and sorting
             * should be implemented by the model.
             * @param model the `GListModel` to be bound to @box
             * @param create_widget_func a function   that creates widgets for items or %NULL in case you also passed %NULL as @model
             */
            bind_model<A extends GObject.Object = GObject.Object>(
                model?: Gio.ListModel<A>,
                create_widget_func?: ListBoxCreateWidgetFunc<A>,
            ): void;
            /**
             * Add a drag highlight to a row.
             *
             * This is a helper function for implementing DnD onto a `GtkListBox`.
             * The passed in `row` will be highlighted by setting the
             * %GTK_STATE_FLAG_DROP_ACTIVE state and any previously highlighted
             * row will be unhighlighted.
             *
             * The row will also be unhighlighted when the widget gets
             * a drag leave event.
             * @param row a `GtkListBoxRow`
             */
            drag_highlight_row(row: ListBoxRow): void;
            /**
             * If a row has previously been highlighted via gtk_list_box_drag_highlight_row(),
             * it will have the highlight removed.
             */
            drag_unhighlight_row(): void;
            /**
             * Returns whether rows activate on single clicks.
             * @returns %TRUE if rows are activated on single click, %FALSE otherwise
             */
            get_activate_on_single_click(): boolean;
            /**
             * Gets the adjustment (if any) that the widget uses to
             * for vertical scrolling.
             * @returns the adjustment
             */
            get_adjustment(): Adjustment | null;
            /**
             * Gets the n-th child in the list (not counting headers).
             *
             * If `index_` is negative or larger than the number of items in the
             * list, %NULL is returned.
             * @param index_ the index of the row
             * @returns the child `GtkWidget`
             */
            get_row_at_index(index_: number): ListBoxRow | null;
            /**
             * Gets the row at the `y` position.
             * @param y position
             * @returns the row
             */
            get_row_at_y(y: number): ListBoxRow | null;
            /**
             * Gets the selected row, or %NULL if no rows are selected.
             *
             * Note that the box may allow multiple selection, in which
             * case you should use [method`Gtk`.ListBox.selected_foreach] to
             * find all selected rows.
             * @returns the selected row
             */
            get_selected_row(): ListBoxRow | null;
            /**
             * Creates a list of all selected children.
             * @returns A `GList` containing the `GtkWidget` for each selected child.   Free with g_list_free() when done.
             */
            get_selected_rows(): ListBoxRow[];
            /**
             * Gets the selection mode of the listbox.
             * @returns a `GtkSelectionMode`
             */
            get_selection_mode(): SelectionMode;
            /**
             * Returns whether the list box should show separators
             * between rows.
             * @returns %TRUE if the list box shows separators
             */
            get_show_separators(): boolean;
            /**
             * Insert the `child` into the `box` at `position`.
             *
             * If a sort function is
             * set, the widget will actually be inserted at the calculated position.
             *
             * If `position` is -1, or larger than the total number of items in the
             * `box,` then the `child` will be appended to the end.
             * @param child the `GtkWidget` to add
             * @param position the position to insert @child in
             */
            insert(child: Widget, position: number): void;
            /**
             * Update the filtering for all rows.
             *
             * Call this when result
             * of the filter function on the `box` is changed due
             * to an external factor. For instance, this would be used
             * if the filter function just looked for a specific search
             * string and the entry with the search string has changed.
             */
            invalidate_filter(): void;
            /**
             * Update the separators for all rows.
             *
             * Call this when result
             * of the header function on the `box` is changed due
             * to an external factor.
             */
            invalidate_headers(): void;
            /**
             * Update the sorting for all rows.
             *
             * Call this when result
             * of the sort function on the `box` is changed due
             * to an external factor.
             */
            invalidate_sort(): void;
            /**
             * Prepend a widget to the list.
             *
             * If a sort function is set, the widget will
             * actually be inserted at the calculated position.
             * @param child the `GtkWidget` to add
             */
            prepend(child: Widget): void;
            /**
             * Removes a child from `box`.
             * @param child the child to remove
             */
            remove(child: Widget): void;
            /**
             * Removes all rows from `box`.
             *
             * This function does nothing if `box` is backed by a model.
             */
            remove_all(): void;
            /**
             * Select all children of `box,` if the selection mode allows it.
             */
            select_all(): void;
            /**
             * Make `row` the currently selected row.
             * @param row The row to select
             */
            select_row(row?: ListBoxRow | null): void;
            /**
             * Calls a function for each selected child.
             *
             * Note that the selection cannot be modified from within this function.
             * @param func the function to call for each selected child
             */
            selected_foreach(func: ListBoxForeachFunc): void;
            /**
             * If `single` is %TRUE, rows will be activated when you click on them,
             * otherwise you need to double-click.
             * @param single a boolean
             */
            set_activate_on_single_click(single: boolean): void;
            /**
             * Sets the adjustment (if any) that the widget uses to
             * for vertical scrolling.
             *
             * For instance, this is used to get the page size for
             * PageUp/Down key handling.
             *
             * In the normal case when the `box` is packed inside
             * a `GtkScrolledWindow` the adjustment from that will
             * be picked up automatically, so there is no need
             * to manually do that.
             * @param adjustment the adjustment
             */
            set_adjustment(adjustment?: Adjustment | null): void;
            /**
             * By setting a filter function on the `box` one can decide dynamically which
             * of the rows to show.
             *
             * For instance, to implement a search function on a list that
             * filters the original list to only show the matching rows.
             *
             * The `filter_func` will be called for each row after the call, and
             * it will continue to be called each time a row changes (via
             * [method`Gtk`.ListBoxRow.changed]) or when [method`Gtk`.ListBox.invalidate_filter]
             * is called.
             *
             * Note that using a filter function is incompatible with using a model
             * (see [method`Gtk`.ListBox.bind_model]).
             * @param filter_func callback   that lets you filter which rows to show
             */
            set_filter_func(filter_func?: ListBoxFilterFunc | null): void;
            /**
             * Sets a header function.
             *
             * By setting a header function on the `box` one can dynamically add headers
             * in front of rows, depending on the contents of the row and its position
             * in the list.
             *
             * For instance, one could use it to add headers in front of the first item
             * of a new kind, in a list sorted by the kind.
             *
             * The `update_header` can look at the current header widget using
             * [method`Gtk`.ListBoxRow.get_header] and either update the state of the widget
             * as needed, or set a new one using [method`Gtk`.ListBoxRow.set_header]. If no
             * header is needed, set the header to %NULL.
             *
             * Note that you may get many calls `update_header` to this for a particular
             * row when e.g. changing things that don’t affect the header. In this case
             * it is important for performance to not blindly replace an existing header
             * with an identical one.
             *
             * The `update_header` function will be called for each row after the call,
             * and it will continue to be called each time a row changes (via
             * [method`Gtk`.ListBoxRow.changed]) and when the row before changes (either
             * by [method`Gtk`.ListBoxRow.changed] on the previous row, or when the previous
             * row becomes a different row). It is also called for all rows when
             * [method`Gtk`.ListBox.invalidate_headers] is called.
             * @param update_header callback   that lets you add row headers
             */
            set_header_func(update_header?: ListBoxUpdateHeaderFunc | null): void;
            /**
             * Sets the placeholder widget that is shown in the list when
             * it doesn't display any visible children.
             * @param placeholder a `GtkWidget`
             */
            set_placeholder(placeholder?: Widget | null): void;
            /**
             * Sets how selection works in the listbox.
             * @param mode The `GtkSelectionMode`
             */
            set_selection_mode(mode: SelectionMode | null): void;
            /**
             * Sets whether the list box should show separators
             * between rows.
             * @param show_separators %TRUE to show separators
             */
            set_show_separators(show_separators: boolean): void;
            /**
             * Sets a sort function.
             *
             * By setting a sort function on the `box` one can dynamically reorder
             * the rows of the list, based on the contents of the rows.
             *
             * The `sort_func` will be called for each row after the call, and will
             * continue to be called each time a row changes (via
             * [method`Gtk`.ListBoxRow.changed]) and when [method`Gtk`.ListBox.invalidate_sort]
             * is called.
             *
             * Note that using a sort function is incompatible with using a model
             * (see [method`Gtk`.ListBox.bind_model]).
             * @param sort_func the sort function
             */
            set_sort_func(sort_func?: ListBoxSortFunc | null): void;
            /**
             * Unselect all children of `box,` if the selection mode allows it.
             */
            unselect_all(): void;
            /**
             * Unselects a single row of `box,` if the selection mode allows it.
             * @param row the row to unselect
             */
            unselect_row(row: ListBoxRow): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ListBoxRow {
            // Signal callback interfaces

            interface Activate {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Actionable.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                activatable: boolean;
                child: Widget;
                selectable: boolean;
            }
        }

        /**
         * `GtkListBoxRow` is the kind of widget that can be added to a `GtkListBox`.
         */
        class ListBoxRow extends Widget implements Accessible, Actionable, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<ListBoxRow>;

            // Properties

            /**
             * Determines whether the ::row-activated
             * signal will be emitted for this row.
             */
            get activatable(): boolean;
            set activatable(val: boolean);
            /**
             * The child widget.
             */
            get child(): Widget;
            set child(val: Widget);
            /**
             * Determines whether this row can be selected.
             */
            get selectable(): boolean;
            set selectable(val: boolean);

            // Constructors

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

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

            static ['new'](): ListBoxRow;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate', callback: (_source: this) => void): number;
            connect_after(signal: 'activate', callback: (_source: this) => void): number;
            emit(signal: 'activate'): void;

            // Virtual methods

            vfunc_activate(): void;

            // Methods

            /**
             * Marks `row` as changed, causing any state that depends on this
             * to be updated.
             *
             * This affects sorting, filtering and headers.
             *
             * Note that calls to this method must be in sync with the data
             * used for the row functions. For instance, if the list is
             * mirroring some external data set, and *two* rows changed in the
             * external data set then when you call gtk_list_box_row_changed()
             * on the first row the sort function must only read the new data
             * for the first of the two changed rows, otherwise the resorting
             * of the rows will be wrong.
             *
             * This generally means that if you don’t fully control the data
             * model you have to duplicate the data that affects the listbox
             * row functions into the row widgets themselves. Another alternative
             * is to call [method`Gtk`.ListBox.invalidate_sort] on any model change,
             * but that is more expensive.
             */
            changed(): void;
            /**
             * Gets whether the row is activatable.
             * @returns %TRUE if the row is activatable
             */
            get_activatable(): boolean;
            /**
             * Gets the child widget of `row`.
             * @returns the child widget of @row
             */
            get_child(): Widget | null;
            /**
             * Returns the current header of the `row`.
             *
             * This can be used
             * in a [callback`Gtk`.ListBoxUpdateHeaderFunc] to see if
             * there is a header set already, and if so to update
             * the state of it.
             * @returns the current header
             */
            get_header(): Widget | null;
            /**
             * Gets the current index of the `row` in its `GtkListBox` container.
             * @returns the index of the @row, or -1 if the @row is not in a listbox
             */
            get_index(): number;
            /**
             * Gets whether the row can be selected.
             * @returns %TRUE if the row is selectable
             */
            get_selectable(): boolean;
            /**
             * Returns whether the child is currently selected in its
             * `GtkListBox` container.
             * @returns %TRUE if @row is selected
             */
            is_selected(): boolean;
            /**
             * Set whether the row is activatable.
             * @param activatable %TRUE to mark the row as activatable
             */
            set_activatable(activatable: boolean): void;
            /**
             * Sets the child widget of `self`.
             * @param child the child widget
             */
            set_child(child?: Widget | null): void;
            /**
             * Sets the current header of the `row`.
             *
             * This is only allowed to be called
             * from a [callback`Gtk`.ListBoxUpdateHeaderFunc].
             * It will replace any existing header in the row,
             * and be shown in front of the row in the listbox.
             * @param header the header
             */
            set_header(header?: Widget | null): void;
            /**
             * Set whether the row can be selected.
             * @param selectable %TRUE to mark the row as selectable
             */
            set_selectable(selectable: boolean): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The name of the action with which this widget should be associated.
             */
            get action_name(): string;
            set action_name(val: string);
            /**
             * The name of the action with which this widget should be associated.
             */
            get actionName(): string;
            set actionName(val: string);
            /**
             * The target value of the actionable widget's action.
             */
            get action_target(): GLib.Variant;
            set action_target(val: GLib.Variant);
            /**
             * The target value of the actionable widget's action.
             */
            get actionTarget(): GLib.Variant;
            set actionTarget(val: GLib.Variant);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the action name for `actionable`.
             * @returns the action name
             */
            get_action_name(): string | null;
            /**
             * Gets the current target value of `actionable`.
             * @returns the current target value
             */
            get_action_target_value(): GLib.Variant | null;
            /**
             * Specifies the name of the action with which this widget should be
             * associated.
             *
             * If `action_name` is %NULL then the widget will be unassociated from
             * any previous action.
             *
             * Usually this function is used when the widget is located (or will be
             * located) within the hierarchy of a `GtkApplicationWindow`.
             *
             * Names are of the form “win.save” or “app.quit” for actions on the
             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
             * associated with the window.
             * @param action_name an action name
             */
            set_action_name(action_name?: string | null): void;
            /**
             * Sets the target value of an actionable widget.
             *
             * If `target_value` is %NULL then the target value is unset.
             *
             * The target value has two purposes. First, it is used as the parameter
             * to activation of the action associated with the `GtkActionable` widget.
             * Second, it is used to determine if the widget should be rendered as
             * “active” — the widget is active if the state is equal to the given target.
             *
             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
             * with string state in a typical “radio button” situation. Each button
             * will be associated with the same action, but with a different target
             * value for that action. Clicking on a particular button will activate
             * the action with the target of that button, which will typically cause
             * the action’s state to change to that value. Since the action’s state
             * is now equal to the target value of the button, the button will now
             * be rendered as active (and the other buttons, with different targets,
             * rendered inactive).
             * @param target_value a [struct@GLib.Variant] to set as the target value
             */
            set_action_target_value(target_value?: GLib.Variant | null): void;
            /**
             * Sets the action-name and associated string target value of an
             * actionable widget.
             *
             * `detailed_action_name` is a string in the format accepted by
             * [func`Gio`.Action.parse_detailed_name].
             * @param detailed_action_name the detailed action name
             */
            set_detailed_action_name(detailed_action_name: string): void;
            /**
             * Gets the action name for `actionable`.
             */
            vfunc_get_action_name(): string | null;
            /**
             * Gets the current target value of `actionable`.
             */
            vfunc_get_action_target_value(): GLib.Variant | null;
            /**
             * Specifies the name of the action with which this widget should be
             * associated.
             *
             * If `action_name` is %NULL then the widget will be unassociated from
             * any previous action.
             *
             * Usually this function is used when the widget is located (or will be
             * located) within the hierarchy of a `GtkApplicationWindow`.
             *
             * Names are of the form “win.save” or “app.quit” for actions on the
             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
             * associated with the window.
             * @param action_name an action name
             */
            vfunc_set_action_name(action_name?: string | null): void;
            /**
             * Sets the target value of an actionable widget.
             *
             * If `target_value` is %NULL then the target value is unset.
             *
             * The target value has two purposes. First, it is used as the parameter
             * to activation of the action associated with the `GtkActionable` widget.
             * Second, it is used to determine if the widget should be rendered as
             * “active” — the widget is active if the state is equal to the given target.
             *
             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
             * with string state in a typical “radio button” situation. Each button
             * will be associated with the same action, but with a different target
             * value for that action. Clicking on a particular button will activate
             * the action with the target of that button, which will typically cause
             * the action’s state to change to that value. Since the action’s state
             * is now equal to the target value of the button, the button will now
             * be rendered as active (and the other buttons, with different targets,
             * rendered inactive).
             * @param target_value a [struct@GLib.Variant] to set as the target value
             */
            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace ListHeader {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                child: Widget;
                end: number;
                item: GObject.Object;
                n_items: number;
                nItems: number;
                start: number;
            }
        }

        /**
         * `GtkListHeader` is used by list widgets to represent the headers they
         * display.
         *
         * `GtkListHeader` objects are managed just like [class`Gtk`.ListItem]
         * objects via their factory, but provide a different set of properties suitable
         * for managing the header instead of individual items.
         */
        class ListHeader extends GObject.Object {
            static $gtype: GObject.GType<ListHeader>;

            // Properties

            /**
             * Widget used for display.
             */
            get child(): Widget;
            set child(val: Widget);
            /**
             * The first position no longer part of this section.
             */
            get end(): number;
            /**
             * The item at the start of the section.
             */
            get item(): GObject.Object;
            /**
             * Number of items in this section.
             */
            get n_items(): number;
            /**
             * Number of items in this section.
             */
            get nItems(): number;
            /**
             * First position of items in this section.
             */
            get start(): number;

            // Constructors

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

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

            // Methods

            /**
             * Gets the child previously set via gtk_list_header_set_child() or
             * %NULL if none was set.
             * @returns The child
             */
            get_child(): Widget | null;
            /**
             * Gets the end position in the model of the section that `self` is
             * currently the header for.
             *
             * If `self` is unbound, %GTK_INVALID_LIST_POSITION is returned.
             * @returns The end position of the section
             */
            get_end(): number;
            /**
             * Gets the model item at the start of the section.
             * This is the item that occupies the list model at position
             * [property`Gtk`.ListHeader:start].
             *
             * If `self` is unbound, this function returns %NULL.
             * @returns The item displayed
             */
            get_item<T = GObject.Object>(): T;
            /**
             * Gets the the number of items in the section.
             *
             * If `self` is unbound, 0 is returned.
             * @returns The number of items in the section
             */
            get_n_items(): number;
            /**
             * Gets the start position in the model of the section that `self` is
             * currently the header for.
             *
             * If `self` is unbound, %GTK_INVALID_LIST_POSITION is returned.
             * @returns The start position of the section
             */
            get_start(): number;
            /**
             * Sets the child to be used for this listitem.
             *
             * This function is typically called by applications when
             * setting up a header so that the widget can be reused when
             * binding it multiple times.
             * @param child The list item's child or %NULL to unset
             */
            set_child(child?: Widget | null): void;
        }

        namespace ListItem {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                accessible_description: string;
                accessibleDescription: string;
                accessible_label: string;
                accessibleLabel: string;
                activatable: boolean;
                child: Widget;
                focusable: boolean;
                item: GObject.Object;
                position: number;
                selectable: boolean;
                selected: boolean;
            }
        }

        /**
         * `GtkListItem` is used by list widgets to represent items in a
         * [iface`Gio`.ListModel].
         *
         * `GtkListItem` objects are managed by the list widget (with its factory)
         * and cannot be created by applications, but they need to be populated
         * by application code. This is done by calling [method`Gtk`.ListItem.set_child].
         *
         * `GtkListItem` objects exist in 2 stages:
         *
         * 1. The unbound stage where the listitem is not currently connected to
         *    an item in the list. In that case, the [property`Gtk`.ListItem:item]
         *    property is set to %NULL.
         *
         * 2. The bound stage where the listitem references an item from the list.
         *    The [property`Gtk`.ListItem:item] property is not %NULL.
         */
        class ListItem extends GObject.Object {
            static $gtype: GObject.GType<ListItem>;

            // Properties

            /**
             * The accessible description to set on the list item.
             */
            get accessible_description(): string;
            set accessible_description(val: string);
            /**
             * The accessible description to set on the list item.
             */
            get accessibleDescription(): string;
            set accessibleDescription(val: string);
            /**
             * The accessible label to set on the list item.
             */
            get accessible_label(): string;
            set accessible_label(val: string);
            /**
             * The accessible label to set on the list item.
             */
            get accessibleLabel(): string;
            set accessibleLabel(val: string);
            /**
             * If the item can be activated by the user.
             */
            get activatable(): boolean;
            set activatable(val: boolean);
            /**
             * Widget used for display.
             */
            get child(): Widget;
            set child(val: Widget);
            /**
             * If the item can be focused with the keyboard.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * Displayed item.
             */
            get item(): GObject.Object;
            /**
             * Position of the item.
             */
            get position(): number;
            /**
             * If the item can be selected by the user.
             */
            get selectable(): boolean;
            set selectable(val: boolean);
            /**
             * If the item is currently selected.
             */
            get selected(): boolean;

            // Constructors

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

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

            // Methods

            /**
             * Gets the accessible description of `self`.
             * @returns the accessible description
             */
            get_accessible_description(): string;
            /**
             * Gets the accessible label of `self`.
             * @returns the accessible label
             */
            get_accessible_label(): string;
            /**
             * Checks if a list item has been set to be activatable via
             * gtk_list_item_set_activatable().
             * @returns %TRUE if the item is activatable
             */
            get_activatable(): boolean;
            /**
             * Gets the child previously set via gtk_list_item_set_child() or
             * %NULL if none was set.
             * @returns The child
             */
            get_child(): Widget | null;
            /**
             * Checks if a list item has been set to be focusable via
             * gtk_list_item_set_focusable().
             * @returns %TRUE if the item is focusable
             */
            get_focusable(): boolean;
            /**
             * Gets the model item that associated with `self`.
             *
             * If `self` is unbound, this function returns %NULL.
             * @returns The item displayed
             */
            get_item<T = GObject.Object>(): T;
            /**
             * Gets the position in the model that `self` currently displays.
             *
             * If `self` is unbound, %GTK_INVALID_LIST_POSITION is returned.
             * @returns The position of this item
             */
            get_position(): number;
            /**
             * Checks if a list item has been set to be selectable via
             * gtk_list_item_set_selectable().
             *
             * Do not confuse this function with [method`Gtk`.ListItem.get_selected].
             * @returns %TRUE if the item is selectable
             */
            get_selectable(): boolean;
            /**
             * Checks if the item is displayed as selected.
             *
             * The selected state is maintained by the list widget and its model
             * and cannot be set otherwise.
             * @returns %TRUE if the item is selected.
             */
            get_selected(): boolean;
            /**
             * Sets the accessible description for the list item,
             * which may be used by e.g. screen readers.
             * @param description the description
             */
            set_accessible_description(description: string): void;
            /**
             * Sets the accessible label for the list item,
             * which may be used by e.g. screen readers.
             * @param label the label
             */
            set_accessible_label(label: string): void;
            /**
             * Sets `self` to be activatable.
             *
             * If an item is activatable, double-clicking on the item, using
             * the Return key or calling gtk_widget_activate() will activate
             * the item. Activating instructs the containing view to handle
             * activation. `GtkListView` for example will be emitting the
             * [signal`Gtk`.ListView::activate] signal.
             *
             * By default, list items are activatable.
             * @param activatable if the item should be activatable
             */
            set_activatable(activatable: boolean): void;
            /**
             * Sets the child to be used for this listitem.
             *
             * This function is typically called by applications when
             * setting up a listitem so that the widget can be reused when
             * binding it multiple times.
             * @param child The list item's child or %NULL to unset
             */
            set_child(child?: Widget | null): void;
            /**
             * Sets `self` to be focusable.
             *
             * If an item is focusable, it can be focused using the keyboard.
             * This works similar to [method`Gtk`.Widget.set_focusable].
             *
             * Note that if items are not focusable, the keyboard cannot be used to activate
             * them and selecting only works if one of the listitem's children is focusable.
             *
             * By default, list items are focusable.
             * @param focusable if the item should be focusable
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets `self` to be selectable.
             *
             * If an item is selectable, clicking on the item or using the keyboard
             * will try to select or unselect the item. If this succeeds is up to
             * the model to determine, as it is managing the selected state.
             *
             * Note that this means that making an item non-selectable has no
             * influence on the selected state at all. A non-selectable item
             * may still be selected.
             *
             * By default, list items are selectable. When rebinding them to
             * a new item, they will also be reset to be selectable by GTK.
             * @param selectable if the item should be selectable
             */
            set_selectable(selectable: boolean): void;
        }

        namespace ListItemFactory {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * A `GtkListItemFactory` creates widgets for the items taken from a `GListModel`.
         *
         * This is one of the core concepts of handling list widgets such
         * as [class`Gtk`.ListView] or [class`Gtk`.GridView].
         *
         * The `GtkListItemFactory` is tasked with creating widgets for items
         * taken from the model when the views need them and updating them as
         * the items displayed by the view change.
         *
         * A view is usually only able to display anything after both a factory
         * and a model have been set on the view. So it is important that you do
         * not skip this step when setting up your first view.
         *
         * Because views do not display the whole list at once but only a few
         * items, they only need to maintain a few widgets at a time. They will
         * instruct the `GtkListItemFactory` to create these widgets and bind them
         * to the items that are currently displayed.
         *
         * As the list model changes or the user scrolls to the list, the items will
         * change and the view will instruct the factory to bind the widgets to those
         * new items.
         *
         * The actual widgets used for displaying those widgets is provided by you.
         *
         * When the factory needs widgets created, it will create a `GtkListItem`
         * and hand it to your code to set up a widget for. This list item will provide
         * various properties with information about what item to display and provide
         * you with some opportunities to configure its behavior. See the
         * [class`Gtk`.ListItem] documentation for further details.
         *
         * Various implementations of `GtkListItemFactory` exist to allow you different
         * ways to provide those widgets. The most common implementations are
         * [class`Gtk`.BuilderListItemFactory] which takes a `GtkBuilder` .ui file
         * and then creates widgets and manages everything automatically from the
         * information in that file and [class`Gtk`.SignalListItemFactory] which allows
         * you to connect to signals with your own code and retain full control over
         * how the widgets are setup and managed.
         *
         * A `GtkListItemFactory` is supposed to be final - that means its behavior should
         * not change and the first widget created from it should behave the same way as
         * the last widget created from it.
         * If you intend to do changes to the behavior, it is recommended that you create
         * a new `GtkListItemFactory` which will allow the views to recreate its widgets.
         *
         * Once you have chosen your factory and created it, you need to set it
         * on the view widget you want to use it with, such as via
         * [method`Gtk`.ListView.set_factory]. Reusing factories across different
         * views is allowed, but very uncommon.
         */
        class ListItemFactory extends GObject.Object {
            static $gtype: GObject.GType<ListItemFactory>;

            // Constructors

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

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

        namespace ListStore {
            // Constructor properties interface

            interface ConstructorProps
                extends GObject.Object.ConstructorProps,
                    Buildable.ConstructorProps,
                    TreeDragDest.ConstructorProps,
                    TreeDragSource.ConstructorProps,
                    TreeModel.ConstructorProps,
                    TreeSortable.ConstructorProps {}
        }

        /**
         * A list-like data structure that can be used with the [class`Gtk`.TreeView].
         *
         * The `GtkListStore` object is a list model for use with a `GtkTreeView`
         * widget.  It implements the `GtkTreeModel` interface, and consequentialy,
         * can use all of the methods available there.  It also implements the
         * `GtkTreeSortable` interface so it can be sorted by the view.
         * Finally, it also implements the tree
         * [drag](iface.TreeDragSource.html) and [drop](iface.TreeDragDest.html)
         * interfaces.
         *
         * The `GtkListStore` can accept most `GType`s as a column type, though
         * it can’t accept all custom types.  Internally, it will keep a copy of
         * data passed in (such as a string or a boxed pointer).  Columns that
         * accept `GObject`s are handled a little differently.  The
         * `GtkListStore` will keep a reference to the object instead of copying the
         * value.  As a result, if the object is modified, it is up to the
         * application writer to call [method`Gtk`.TreeModel.row_changed] to emit the
         * [signal`Gtk`.TreeModel::row_changed] signal. This most commonly affects lists
         * with [class`Gdk`.Texture]s stored.
         *
         * An example for creating a simple list store:
         *
         * ```c
         * enum {
         *   COLUMN_STRING,
         *   COLUMN_INT,
         *   COLUMN_BOOLEAN,
         *   N_COLUMNS
         * };
         *
         * {
         *   GtkListStore *list_store;
         *   GtkTreePath *path;
         *   GtkTreeIter iter;
         *   int i;
         *
         *   list_store = gtk_list_store_new (N_COLUMNS,
         *                                    G_TYPE_STRING,
         *                                    G_TYPE_INT,
         *                                    G_TYPE_BOOLEAN);
         *
         *   for (i = 0; i < 10; i++)
         *     {
         *       char *some_data;
         *
         *       some_data = get_some_data (i);
         *
         *       // Add a new row to the model
         *       gtk_list_store_append (list_store, &iter);
         *       gtk_list_store_set (list_store, &iter,
         *                           COLUMN_STRING, some_data,
         *                           COLUMN_INT, i,
         *                           COLUMN_BOOLEAN,  FALSE,
         *                           -1);
         *
         *       // As the store will keep a copy of the string internally,
         *       // we free some_data.
         *       g_free (some_data);
         *     }
         *
         *   // Modify a particular row
         *   path = gtk_tree_path_new_from_string ("4");
         *   gtk_tree_model_get_iter (GTK_TREE_MODEL (list_store),
         *                            &iter,
         *                            path);
         *   gtk_tree_path_free (path);
         *   gtk_list_store_set (list_store, &iter,
         *                       COLUMN_BOOLEAN, TRUE,
         *                       -1);
         * }
         * ```
         *
         * `GtkListStore` is deprecated since GTK 4.10, and should not be used in newly
         * written code. You should use [class`Gio`.ListStore] instead, and the various
         * list models provided by GTK.
         *
         * ## Performance Considerations
         *
         * Internally, the `GtkListStore` was originally implemented with a linked list
         * with a tail pointer.  As a result, it was fast at data insertion and deletion,
         * and not fast at random data access.  The `GtkListStore` sets the
         * `GTK_TREE_MODEL_ITERS_PERSIST` flag, which means that `GtkTreeIter`s can be
         * cached while the row exists.  Thus, if access to a particular row is needed
         * often and your code is expected to run on older versions of GTK, it is worth
         * keeping the iter around.
         *
         * ## Atomic Operations
         *
         * It is important to note that only the methods
         * gtk_list_store_insert_with_values() and gtk_list_store_insert_with_valuesv()
         * are atomic, in the sense that the row is being appended to the store and the
         * values filled in in a single operation with regard to `GtkTreeModel` signaling.
         * In contrast, using e.g. gtk_list_store_append() and then gtk_list_store_set()
         * will first create a row, which triggers the `GtkTreeModel::row-inserted` signal
         * on `GtkListStore`. The row, however, is still empty, and any signal handler
         * connecting to `GtkTreeModel::row-inserted` on this particular store should be prepared
         * for the situation that the row might be empty. This is especially important
         * if you are wrapping the `GtkListStore` inside a `GtkTreeModel`Filter and are
         * using a `GtkTreeModel`FilterVisibleFunc. Using any of the non-atomic operations
         * to append rows to the `GtkListStore` will cause the
         * `GtkTreeModel`FilterVisibleFunc to be visited with an empty row first; the
         * function must be prepared for that.
         *
         * ## GtkListStore as GtkBuildable
         *
         * The GtkListStore implementation of the [iface`Gtk`.Buildable] interface allows
         * to specify the model columns with a `<columns>` element that may contain
         * multiple `<column>` elements, each specifying one model column. The “type”
         * attribute specifies the data type for the column.
         *
         * Additionally, it is possible to specify content for the list store
         * in the UI definition, with the `<data>` element. It can contain multiple
         * `<row>` elements, each specifying to content for one row of the list model.
         * Inside a `<row>`, the `<col>` elements specify the content for individual cells.
         *
         * Note that it is probably more common to define your models in the code,
         * and one might consider it a layering violation to specify the content of
         * a list store in a UI definition, data, not presentation, and common wisdom
         * is to separate the two, as far as possible.
         *
         * An example of a UI Definition fragment for a list store:
         *
         * ```xml
         * <object class="GtkListStore">
         *   <columns>
         *     <column type="gchararray"/>
         *     <column type="gchararray"/>
         *     <column type="gint"/>
         *   </columns>
         *   <data>
         *     <row>
         *       <col id="0">John</col>
         *       <col id="1">Doe</col>
         *       <col id="2">25</col>
         *     </row>
         *     <row>
         *       <col id="0">Johan</col>
         *       <col id="1">Dahlin</col>
         *       <col id="2">50</col>
         *     </row>
         *   </data>
         * </object>
         * ```
         */
        class ListStore
            extends GObject.Object
            implements Buildable, TreeDragDest, TreeDragSource, TreeModel, TreeSortable
        {
            static $gtype: GObject.GType<ListStore>;

            // Constructors

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

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

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

            // Methods

            /**
             * Appends a new row to `list_store`.  `iter` will be changed to point to this new
             * row.  The row will be empty after this function is called.  To fill in
             * values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
             */
            append(): TreeIter;
            /**
             * Removes all rows from the list store.
             */
            clear(): void;
            /**
             * Creates a new row at `position`.  `iter` will be changed to point to this new
             * row.  If `position` is -1 or is larger than the number of rows on the list,
             * then the new row will be appended to the list. The row will be empty after
             * this function is called.  To fill in values, you need to call
             * gtk_list_store_set() or gtk_list_store_set_value().
             * @param position position to insert the new row, or -1 for last
             */
            insert(position: number): TreeIter;
            /**
             * Inserts a new row after `sibling`. If `sibling` is %NULL, then the row will be
             * prepended to the beginning of the list. `iter` will be changed to point to
             * this new row. The row will be empty after this function is called. To fill
             * in values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
             * @param sibling A valid `GtkTreeIter`
             */
            insert_after(sibling?: TreeIter | null): TreeIter;
            /**
             * Inserts a new row before `sibling`. If `sibling` is %NULL, then the row will
             * be appended to the end of the list. `iter` will be changed to point to this
             * new row. The row will be empty after this function is called. To fill in
             * values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
             * @param sibling A valid `GtkTreeIter`
             */
            insert_before(sibling?: TreeIter | null): TreeIter;
            /**
             * A variant of gtk_list_store_insert_with_values() which
             * takes the columns and values as two arrays, instead of
             * varargs.
             *
             * This function is mainly intended for language-bindings.
             * @param position position to insert the new row, or -1 for last
             * @param columns an array of column numbers
             * @param values an array of GValues
             */
            insert_with_values(position: number, columns: number[], values: (GObject.Value | any)[]): TreeIter | null;
            /**
             * Checks if the given iter is a valid iter for this `GtkListStore`.
             *
             * This function is slow. Only use it for debugging and/or testing
             * purposes.
             * @param iter the iterator to check
             * @returns %TRUE if the iter is valid, %FALSE if the iter is invalid.
             */
            iter_is_valid(iter: TreeIter): boolean;
            /**
             * Moves `iter` in `store` to the position after `position`. Note that this
             * function only works with unsorted stores. If `position` is %NULL, `iter`
             * will be moved to the start of the list.
             * @param iter A `GtkTreeIter`
             * @param position A `GtkTreeIter`
             */
            move_after(iter: TreeIter, position?: TreeIter | null): void;
            /**
             * Moves `iter` in `store` to the position before `position`. Note that this
             * function only works with unsorted stores. If `position` is %NULL, `iter`
             * will be moved to the end of the list.
             * @param iter A `GtkTreeIter`
             * @param position A `GtkTreeIter`
             */
            move_before(iter: TreeIter, position?: TreeIter | null): void;
            /**
             * Prepends a new row to `list_store`. `iter` will be changed to point to this new
             * row. The row will be empty after this function is called. To fill in
             * values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
             */
            prepend(): TreeIter;
            /**
             * Removes the given row from the list store.  After being removed,
             * `iter` is set to be the next valid row, or invalidated if it pointed
             * to the last row in `list_store`.
             * @param iter A valid `GtkTreeIter`
             * @returns %TRUE if @iter is valid, %FALSE if not.
             */
            remove(iter: TreeIter): boolean;
            /**
             * Reorders `store` to follow the order indicated by `new_order`. Note that
             * this function only works with unsorted stores.
             * @param new_order an array of integers mapping the new   position of each child to its old position before the re-ordering,   i.e. @new_order`[newpos] = oldpos`. It must have   exactly as many items as the list store’s length.
             */
            reorder(new_order: number[]): void;
            /**
             * Sets the types of the columns of a list store.
             *
             * This function is meant primarily for objects that inherit
             * from `GtkListStore`, and should only be used when constructing
             * a new instance.
             *
             * This function cannot be called after a row has been added, or
             * a method on the `GtkTreeModel` interface is called.
             * @param types An array length n of `GType`s
             */
            set_column_types(types: GObject.GType[]): void;
            /**
             * Sets the data in the cell specified by `iter` and `column`.
             * The type of `value` must be convertible to the type of the
             * column.
             * @param iter A valid `GtkTreeIter` for the row being modified
             * @param column column number to modify
             * @param value new value for the cell
             */
            set_value(iter: TreeIter, column: number, value: GObject.Value | any): void;
            /**
             * A variant of gtk_list_store_set_valist() which
             * takes the columns and values as two arrays, instead of
             * varargs. This function is mainly intended for
             * language-bindings and in case the number of columns to
             * change is not known until run-time.
             * @param iter A valid `GtkTreeIter` for the row being modified
             * @param columns an array of column numbers
             * @param values an array of GValues
             */
            set(iter: TreeIter, columns: number[], values: (GObject.Value | any)[]): void;
            // Conflicted with GObject.Object.set
            set(...args: never[]): any;
            /**
             * Swaps `a` and `b` in `store`. Note that this function only works with
             * unsorted stores.
             * @param a A `GtkTreeIter`
             * @param b Another `GtkTreeIter`
             */
            swap(a: TreeIter, b: TreeIter): void;

            // Inherited methods
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Asks the `GtkTreeDragDest` to insert a row before the path `dest,`
             * deriving the contents of the row from `value`. If `dest` is
             * outside the tree so that inserting before it is impossible, %FALSE
             * will be returned. Also, %FALSE may be returned if the new row is
             * not created for some model-specific reason.  Should robustly handle
             * a `dest` no longer found in the model!
             * @param dest row to drop in front of
             * @param value data to drop
             * @returns whether a new row was created before position @dest
             */
            drag_data_received(dest: TreePath, value: GObject.Value | any): boolean;
            /**
             * Determines whether a drop is possible before the given `dest_path,`
             * at the same depth as `dest_path`. i.e., can we drop the data in
             * `value` at that location. `dest_path` does not have to
             * exist; the return value will almost certainly be %FALSE if the
             * parent of `dest_path` doesn’t exist, though.
             * @param dest_path destination row
             * @param value the data being dropped
             * @returns %TRUE if a drop is possible before @dest_path
             */
            row_drop_possible(dest_path: TreePath, value: GObject.Value | any): boolean;
            /**
             * Asks the `GtkTreeDragDest` to insert a row before the path `dest,`
             * deriving the contents of the row from `value`. If `dest` is
             * outside the tree so that inserting before it is impossible, %FALSE
             * will be returned. Also, %FALSE may be returned if the new row is
             * not created for some model-specific reason.  Should robustly handle
             * a `dest` no longer found in the model!
             * @param dest row to drop in front of
             * @param value data to drop
             */
            vfunc_drag_data_received(dest: TreePath, value: GObject.Value | any): boolean;
            /**
             * Determines whether a drop is possible before the given `dest_path,`
             * at the same depth as `dest_path`. i.e., can we drop the data in
             * `value` at that location. `dest_path` does not have to
             * exist; the return value will almost certainly be %FALSE if the
             * parent of `dest_path` doesn’t exist, though.
             * @param dest_path destination row
             * @param value the data being dropped
             */
            vfunc_row_drop_possible(dest_path: TreePath, value: GObject.Value | any): boolean;
            /**
             * Asks the `GtkTreeDragSource` to delete the row at `path,` because
             * it was moved somewhere else via drag-and-drop. Returns %FALSE
             * if the deletion fails because `path` no longer exists, or for
             * some model-specific reason. Should robustly handle a `path` no
             * longer found in the model!
             * @param path row that was being dragged
             * @returns %TRUE if the row was successfully deleted
             */
            drag_data_delete(path: TreePath): boolean;
            /**
             * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
             * the row at `path`. Should robustly handle a `path` no
             * longer found in the model!
             * @param path row that was dragged
             * @returns a `GdkContentProvider` for the    given @path
             */
            drag_data_get(path: TreePath): Gdk.ContentProvider | null;
            /**
             * Asks the `GtkTreeDragSource` whether a particular row can be used as
             * the source of a DND operation. If the source doesn’t implement
             * this interface, the row is assumed draggable.
             * @param path row on which user is initiating a drag
             * @returns %TRUE if the row can be dragged
             */
            row_draggable(path: TreePath): boolean;
            /**
             * Asks the `GtkTreeDragSource` to delete the row at `path,` because
             * it was moved somewhere else via drag-and-drop. Returns %FALSE
             * if the deletion fails because `path` no longer exists, or for
             * some model-specific reason. Should robustly handle a `path` no
             * longer found in the model!
             * @param path row that was being dragged
             */
            vfunc_drag_data_delete(path: TreePath): boolean;
            /**
             * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
             * the row at `path`. Should robustly handle a `path` no
             * longer found in the model!
             * @param path row that was dragged
             */
            vfunc_drag_data_get(path: TreePath): Gdk.ContentProvider | null;
            /**
             * Asks the `GtkTreeDragSource` whether a particular row can be used as
             * the source of a DND operation. If the source doesn’t implement
             * this interface, the row is assumed draggable.
             * @param path row on which user is initiating a drag
             */
            vfunc_row_draggable(path: TreePath): boolean;
            /**
             * Creates a new `GtkTreeModel`, with `child_model` as the child_model
             * and `root` as the virtual root.
             * @param root A `GtkTreePath`
             * @returns A new `GtkTreeModel`.
             */
            filter_new(root?: TreePath | null): TreeModel;
            /**
             * Calls `func` on each node in model in a depth-first fashion.
             *
             * If `func` returns %TRUE, then the tree ceases to be walked,
             * and gtk_tree_model_foreach() returns.
             * @param func a function to be called on each row
             */
            foreach(func: TreeModelForeachFunc): void;
            /**
             * Returns the type of the column.
             * @param index_ the column index
             * @returns the type of the column
             */
            get_column_type(index_: number): GObject.GType;
            /**
             * Returns a set of flags supported by this interface.
             *
             * The flags are a bitwise combination of `GtkTreeModel`Flags.
             * The flags supported should not change during the lifetime
             * of the `tree_model`.
             * @returns the flags supported by this interface
             */
            get_flags(): TreeModelFlags;
            /**
             * Sets `iter` to a valid iterator pointing to `path`.
             *
             * If `path` does not exist, `iter` is set to an invalid
             * iterator and %FALSE is returned.
             * @param path the `GtkTreePath`
             * @returns %TRUE, if @iter was set
             */
            get_iter(path: TreePath): [boolean, TreeIter];
            /**
             * Initializes `iter` with the first iterator in the tree
             * (the one at the path "0").
             *
             * Returns %FALSE if the tree is empty, %TRUE otherwise.
             * @returns %TRUE, if @iter was set
             */
            get_iter_first(): [boolean, TreeIter];
            /**
             * Sets `iter` to a valid iterator pointing to `path_string,` if it
             * exists.
             *
             * Otherwise, `iter` is left invalid and %FALSE is returned.
             * @param path_string a string representation of a `GtkTreePath`
             * @returns %TRUE, if @iter was set
             */
            get_iter_from_string(path_string: string): [boolean, TreeIter];
            /**
             * Returns the number of columns supported by `tree_model`.
             * @returns the number of columns
             */
            get_n_columns(): number;
            /**
             * Returns a newly-created `GtkTreePath` referenced by `iter`.
             *
             * This path should be freed with gtk_tree_path_free().
             * @param iter the `GtkTreeIter`
             * @returns a newly-created `GtkTreePath`
             */
            get_path(iter: TreeIter): TreePath;
            /**
             * Generates a string representation of the iter.
             *
             * This string is a “:” separated list of numbers.
             * For example, “4:10:0:3” would be an acceptable
             * return value for this string.
             * @param iter a `GtkTreeIter`
             * @returns a newly-allocated string
             */
            get_string_from_iter(iter: TreeIter): string | null;
            /**
             * Initializes and sets `value` to that at `column`.
             *
             * When done with `value,` g_value_unset() needs to be called
             * to free any allocated memory.
             * @param iter the `GtkTreeIter`
             * @param column the column to lookup the value at
             */
            get_value(iter: TreeIter, column: number): unknown;
            /**
             * Sets `iter` to point to the first child of `parent`.
             *
             * If `parent` has no children, %FALSE is returned and `iter` is
             * set to be invalid. `parent` will remain a valid node after this
             * function has been called.
             *
             * If `parent` is %NULL returns the first node, equivalent to
             * `gtk_tree_model_get_iter_first (tree_model, iter);`
             * @param parent the `GtkTreeIter`
             * @returns %TRUE, if @iter has been set to the first child
             */
            iter_children(parent?: TreeIter | null): [boolean, TreeIter];
            /**
             * Returns %TRUE if `iter` has children, %FALSE otherwise.
             * @param iter the `GtkTreeIter` to test for children
             * @returns %TRUE if @iter has children
             */
            iter_has_child(iter: TreeIter): boolean;
            /**
             * Returns the number of children that `iter` has.
             *
             * As a special case, if `iter` is %NULL, then the number
             * of toplevel nodes is returned.
             * @param iter the `GtkTreeIter`
             * @returns the number of children of @iter
             */
            iter_n_children(iter?: TreeIter | null): number;
            /**
             * Sets `iter` to point to the node following it at the current level.
             *
             * If there is no next `iter,` %FALSE is returned and `iter` is set
             * to be invalid.
             * @param iter the `GtkTreeIter`
             * @returns %TRUE if @iter has been changed to the next node
             */
            iter_next(iter: TreeIter): boolean;
            /**
             * Sets `iter` to be the child of `parent,` using the given index.
             *
             * The first index is 0. If `n` is too big, or `parent` has no children,
             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
             * will remain a valid node after this function has been called. As a
             * special case, if `parent` is %NULL, then the `n-th` root node
             * is set.
             * @param parent the `GtkTreeIter` to get the child from
             * @param n the index of the desired child
             * @returns %TRUE, if @parent has an @n-th child
             */
            iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
            /**
             * Sets `iter` to be the parent of `child`.
             *
             * If `child` is at the toplevel, and doesn’t have a parent, then
             * `iter` is set to an invalid iterator and %FALSE is returned.
             * `child` will remain a valid node after this function has been
             * called.
             *
             * `iter` will be initialized before the lookup is performed, so `child`
             * and `iter` cannot point to the same memory location.
             * @param child the `GtkTreeIter`
             * @returns %TRUE, if @iter is set to the parent of @child
             */
            iter_parent(child: TreeIter): [boolean, TreeIter];
            /**
             * Sets `iter` to point to the previous node at the current level.
             *
             * If there is no previous `iter,` %FALSE is returned and `iter` is
             * set to be invalid.
             * @param iter the `GtkTreeIter`
             * @returns %TRUE if @iter has been changed to the previous node
             */
            iter_previous(iter: TreeIter): boolean;
            /**
             * Lets the tree ref the node.
             *
             * This is an optional method for models to implement.
             * To be more specific, models may ignore this call as it exists
             * primarily for performance reasons.
             *
             * This function is primarily meant as a way for views to let
             * caching models know when nodes are being displayed (and hence,
             * whether or not to cache that node). Being displayed means a node
             * is in an expanded branch, regardless of whether the node is currently
             * visible in the viewport. For example, a file-system based model
             * would not want to keep the entire file-hierarchy in memory,
             * just the sections that are currently being displayed by
             * every current view.
             *
             * A model should be expected to be able to get an iter independent
             * of its reffed state.
             * @param iter the `GtkTreeIter`
             */
            ref_node(iter: TreeIter): void;
            /**
             * Emits the ::row-changed signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-changed].
             * @param path a `GtkTreePath` pointing to the changed row
             * @param iter a valid `GtkTreeIter` pointing to the changed row
             */
            row_changed(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::row-deleted signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-deleted].
             *
             * This should be called by models after a row has been removed.
             * The location pointed to by `path` should be the location that
             * the row previously was at. It may not be a valid location anymore.
             *
             * Nodes that are deleted are not unreffed, this means that any
             * outstanding references on the deleted node should not be released.
             * @param path a `GtkTreePath` pointing to the previous location of   the deleted row
             */
            row_deleted(path: TreePath): void;
            /**
             * Emits the ::row-has-child-toggled signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-has-child-toggled].
             *
             * This should be called by models after the child
             * state of a node changes.
             * @param path a `GtkTreePath` pointing to the changed row
             * @param iter a valid `GtkTreeIter` pointing to the changed row
             */
            row_has_child_toggled(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::row-inserted signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-inserted].
             * @param path a `GtkTreePath` pointing to the inserted row
             * @param iter a valid `GtkTreeIter` pointing to the inserted row
             */
            row_inserted(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::rows-reordered signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::rows-reordered].
             *
             * This should be called by models when their rows have been
             * reordered.
             * @param path a `GtkTreePath` pointing to the tree node whose children   have been reordered
             * @param iter a valid `GtkTreeIter` pointing to the node   whose children have been reordered, or %NULL if the depth   of @path is 0
             * @param new_order an array of integers   mapping the current position of each child to its old   position before the re-ordering,   i.e. @new_order`[newpos] = oldpos`
             */
            rows_reordered(path: TreePath, iter: TreeIter | null, new_order: number[]): void;
            /**
             * Lets the tree unref the node.
             *
             * This is an optional method for models to implement.
             * To be more specific, models may ignore this call as it exists
             * primarily for performance reasons. For more information on what
             * this means, see gtk_tree_model_ref_node().
             *
             * Please note that nodes that are deleted are not unreffed.
             * @param iter the `GtkTreeIter`
             */
            unref_node(iter: TreeIter): void;
            /**
             * Returns the type of the column.
             * @param index_ the column index
             */
            vfunc_get_column_type(index_: number): GObject.GType;
            /**
             * Returns a set of flags supported by this interface.
             *
             * The flags are a bitwise combination of `GtkTreeModel`Flags.
             * The flags supported should not change during the lifetime
             * of the `tree_model`.
             */
            vfunc_get_flags(): TreeModelFlags;
            /**
             * Sets `iter` to a valid iterator pointing to `path`.
             *
             * If `path` does not exist, `iter` is set to an invalid
             * iterator and %FALSE is returned.
             * @param path the `GtkTreePath`
             */
            vfunc_get_iter(path: TreePath): [boolean, TreeIter];
            /**
             * Returns the number of columns supported by `tree_model`.
             */
            vfunc_get_n_columns(): number;
            /**
             * Returns a newly-created `GtkTreePath` referenced by `iter`.
             *
             * This path should be freed with gtk_tree_path_free().
             * @param iter the `GtkTreeIter`
             */
            vfunc_get_path(iter: TreeIter): TreePath;
            /**
             * Initializes and sets `value` to that at `column`.
             *
             * When done with `value,` g_value_unset() needs to be called
             * to free any allocated memory.
             * @param iter the `GtkTreeIter`
             * @param column the column to lookup the value at
             */
            vfunc_get_value(iter: TreeIter, column: number): unknown;
            /**
             * Sets `iter` to point to the first child of `parent`.
             *
             * If `parent` has no children, %FALSE is returned and `iter` is
             * set to be invalid. `parent` will remain a valid node after this
             * function has been called.
             *
             * If `parent` is %NULL returns the first node, equivalent to
             * `gtk_tree_model_get_iter_first (tree_model, iter);`
             * @param parent the `GtkTreeIter`
             */
            vfunc_iter_children(parent?: TreeIter | null): [boolean, TreeIter];
            /**
             * Returns %TRUE if `iter` has children, %FALSE otherwise.
             * @param iter the `GtkTreeIter` to test for children
             */
            vfunc_iter_has_child(iter: TreeIter): boolean;
            /**
             * Returns the number of children that `iter` has.
             *
             * As a special case, if `iter` is %NULL, then the number
             * of toplevel nodes is returned.
             * @param iter the `GtkTreeIter`
             */
            vfunc_iter_n_children(iter?: TreeIter | null): number;
            /**
             * Sets `iter` to point to the node following it at the current level.
             *
             * If there is no next `iter,` %FALSE is returned and `iter` is set
             * to be invalid.
             * @param iter the `GtkTreeIter`
             */
            vfunc_iter_next(iter: TreeIter): boolean;
            /**
             * Sets `iter` to be the child of `parent,` using the given index.
             *
             * The first index is 0. If `n` is too big, or `parent` has no children,
             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
             * will remain a valid node after this function has been called. As a
             * special case, if `parent` is %NULL, then the `n-th` root node
             * is set.
             * @param parent the `GtkTreeIter` to get the child from
             * @param n the index of the desired child
             */
            vfunc_iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
            /**
             * Sets `iter` to be the parent of `child`.
             *
             * If `child` is at the toplevel, and doesn’t have a parent, then
             * `iter` is set to an invalid iterator and %FALSE is returned.
             * `child` will remain a valid node after this function has been
             * called.
             *
             * `iter` will be initialized before the lookup is performed, so `child`
             * and `iter` cannot point to the same memory location.
             * @param child the `GtkTreeIter`
             */
            vfunc_iter_parent(child: TreeIter): [boolean, TreeIter];
            /**
             * Sets `iter` to point to the previous node at the current level.
             *
             * If there is no previous `iter,` %FALSE is returned and `iter` is
             * set to be invalid.
             * @param iter the `GtkTreeIter`
             */
            vfunc_iter_previous(iter: TreeIter): boolean;
            /**
             * Lets the tree ref the node.
             *
             * This is an optional method for models to implement.
             * To be more specific, models may ignore this call as it exists
             * primarily for performance reasons.
             *
             * This function is primarily meant as a way for views to let
             * caching models know when nodes are being displayed (and hence,
             * whether or not to cache that node). Being displayed means a node
             * is in an expanded branch, regardless of whether the node is currently
             * visible in the viewport. For example, a file-system based model
             * would not want to keep the entire file-hierarchy in memory,
             * just the sections that are currently being displayed by
             * every current view.
             *
             * A model should be expected to be able to get an iter independent
             * of its reffed state.
             * @param iter the `GtkTreeIter`
             */
            vfunc_ref_node(iter: TreeIter): void;
            /**
             * Emits the ::row-changed signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-changed].
             * @param path a `GtkTreePath` pointing to the changed row
             * @param iter a valid `GtkTreeIter` pointing to the changed row
             */
            vfunc_row_changed(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::row-deleted signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-deleted].
             *
             * This should be called by models after a row has been removed.
             * The location pointed to by `path` should be the location that
             * the row previously was at. It may not be a valid location anymore.
             *
             * Nodes that are deleted are not unreffed, this means that any
             * outstanding references on the deleted node should not be released.
             * @param path a `GtkTreePath` pointing to the previous location of   the deleted row
             */
            vfunc_row_deleted(path: TreePath): void;
            /**
             * Emits the ::row-has-child-toggled signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-has-child-toggled].
             *
             * This should be called by models after the child
             * state of a node changes.
             * @param path a `GtkTreePath` pointing to the changed row
             * @param iter a valid `GtkTreeIter` pointing to the changed row
             */
            vfunc_row_has_child_toggled(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::row-inserted signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-inserted].
             * @param path a `GtkTreePath` pointing to the inserted row
             * @param iter a valid `GtkTreeIter` pointing to the inserted row
             */
            vfunc_row_inserted(path: TreePath, iter: TreeIter): void;
            /**
             * Lets the tree unref the node.
             *
             * This is an optional method for models to implement.
             * To be more specific, models may ignore this call as it exists
             * primarily for performance reasons. For more information on what
             * this means, see gtk_tree_model_ref_node().
             *
             * Please note that nodes that are deleted are not unreffed.
             * @param iter the `GtkTreeIter`
             */
            vfunc_unref_node(iter: TreeIter): void;
            /**
             * Fills in `sort_column_id` and `order` with the current sort column and the
             * order. It returns %TRUE unless the `sort_column_id` is
             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
             * @returns %TRUE if the sort column is not one of the special sort   column ids.
             */
            get_sort_column_id(): [boolean, number, SortType];
            /**
             * Returns %TRUE if the model has a default sort function. This is used
             * primarily by GtkTreeViewColumns in order to determine if a model can
             * go back to the default state, or not.
             * @returns %TRUE, if the model has a default sort function
             */
            has_default_sort_func(): boolean;
            /**
             * Sets the default comparison function used when sorting to be `sort_func`.
             * If the current sort column id of `sortable` is
             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
             * this function.
             *
             * If `sort_func` is %NULL, then there will be no default comparison function.
             * This means that once the model  has been sorted, it can’t go back to the
             * default state. In this case, when the current sort column id of `sortable`
             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
             * @param sort_func The comparison function
             * @param destroy Destroy notifier of @user_data
             */
            set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
            /**
             * Sets the current sort column to be `sort_column_id`. The `sortable` will
             * resort itself to reflect this change, after emitting a
             * `GtkTreeSortable::sort-column-changed` signal. `sort_column_id` may either be
             * a regular column id, or one of the following special values:
             *
             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
             *   will be used, if it is set
             *
             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
             * @param sort_column_id the sort column id to set
             * @param order The sort order of the column
             */
            set_sort_column_id(sort_column_id: number, order: SortType | null): void;
            /**
             * Sets the comparison function used when sorting to be `sort_func`. If the
             * current sort column id of `sortable` is the same as `sort_column_id,` then
             * the model will sort using this function.
             * @param sort_column_id the sort column id to set the function for
             * @param sort_func The comparison function
             * @param destroy Destroy notifier of @user_data
             */
            set_sort_func(
                sort_column_id: number,
                sort_func: TreeIterCompareFunc,
                destroy?: GLib.DestroyNotify | null,
            ): void;
            /**
             * Emits a `GtkTreeSortable::sort-column-changed` signal on `sortable`.
             */
            sort_column_changed(): void;
            /**
             * Fills in `sort_column_id` and `order` with the current sort column and the
             * order. It returns %TRUE unless the `sort_column_id` is
             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
             */
            vfunc_get_sort_column_id(): [boolean, number, SortType];
            /**
             * Returns %TRUE if the model has a default sort function. This is used
             * primarily by GtkTreeViewColumns in order to determine if a model can
             * go back to the default state, or not.
             */
            vfunc_has_default_sort_func(): boolean;
            /**
             * Sets the default comparison function used when sorting to be `sort_func`.
             * If the current sort column id of `sortable` is
             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
             * this function.
             *
             * If `sort_func` is %NULL, then there will be no default comparison function.
             * This means that once the model  has been sorted, it can’t go back to the
             * default state. In this case, when the current sort column id of `sortable`
             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
             * @param sort_func The comparison function
             * @param destroy Destroy notifier of @user_data
             */
            vfunc_set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
            /**
             * Sets the current sort column to be `sort_column_id`. The `sortable` will
             * resort itself to reflect this change, after emitting a
             * `GtkTreeSortable::sort-column-changed` signal. `sort_column_id` may either be
             * a regular column id, or one of the following special values:
             *
             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
             *   will be used, if it is set
             *
             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
             * @param sort_column_id the sort column id to set
             * @param order The sort order of the column
             */
            vfunc_set_sort_column_id(sort_column_id: number, order: SortType): void;
            /**
             * Sets the comparison function used when sorting to be `sort_func`. If the
             * current sort column id of `sortable` is the same as `sort_column_id,` then
             * the model will sort using this function.
             * @param sort_column_id the sort column id to set the function for
             * @param sort_func The comparison function
             * @param destroy Destroy notifier of @user_data
             */
            vfunc_set_sort_func(
                sort_column_id: number,
                sort_func: TreeIterCompareFunc,
                destroy?: GLib.DestroyNotify | null,
            ): void;
            /**
             * Emits a `GtkTreeSortable::sort-column-changed` signal on `sortable`.
             */
            vfunc_sort_column_changed(): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ListView {
            // Signal callback interfaces

            interface Activate {
                (position: number): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends ListBase.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Orientable.ConstructorProps,
                    Scrollable.ConstructorProps {
                enable_rubberband: boolean;
                enableRubberband: boolean;
                factory: ListItemFactory;
                header_factory: ListItemFactory;
                headerFactory: ListItemFactory;
                model: SelectionModel;
                show_separators: boolean;
                showSeparators: boolean;
                single_click_activate: boolean;
                singleClickActivate: boolean;
                tab_behavior: ListTabBehavior;
                tabBehavior: ListTabBehavior;
            }
        }

        /**
         * `GtkListView` presents a large dynamic list of items.
         *
         * `GtkListView` uses its factory to generate one row widget for each visible
         * item and shows them in a linear display, either vertically or horizontally.
         *
         * The [property`Gtk`.ListView:show-separators] property offers a simple way to
         * display separators between the rows.
         *
         * `GtkListView` allows the user to select items according to the selection
         * characteristics of the model. For models that allow multiple selected items,
         * it is possible to turn on _rubberband selection_, using
         * [property`Gtk`.ListView:enable-rubberband].
         *
         * If you need multiple columns with headers, see [class`Gtk`.ColumnView].
         *
         * To learn more about the list widget framework, see the
         * [overview](section-list-widget.html).
         *
         * An example of using `GtkListView`:
         * ```c
         * static void
         * setup_listitem_cb (GtkListItemFactory *factory,
         *                    GtkListItem        *list_item)
         * {
         *   GtkWidget *image;
         *
         *   image = gtk_image_new ();
         *   gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE);
         *   gtk_list_item_set_child (list_item, image);
         * }
         *
         * static void
         * bind_listitem_cb (GtkListItemFactory *factory,
         *                   GtkListItem        *list_item)
         * {
         *   GtkWidget *image;
         *   GAppInfo *app_info;
         *
         *   image = gtk_list_item_get_child (list_item);
         *   app_info = gtk_list_item_get_item (list_item);
         *   gtk_image_set_from_gicon (GTK_IMAGE (image), g_app_info_get_icon (app_info));
         * }
         *
         * static void
         * activate_cb (GtkListView  *list,
         *              guint         position,
         *              gpointer      unused)
         * {
         *   GAppInfo *app_info;
         *
         *   app_info = g_list_model_get_item (G_LIST_MODEL (gtk_list_view_get_model (list)), position);
         *   g_app_info_launch (app_info, NULL, NULL, NULL);
         *   g_object_unref (app_info);
         * }
         *
         * ...
         *
         *   model = create_application_list ();
         *
         *   factory = gtk_signal_list_item_factory_new ();
         *   g_signal_connect (factory, "setup", G_CALLBACK (setup_listitem_cb), NULL);
         *   g_signal_connect (factory, "bind", G_CALLBACK (bind_listitem_cb), NULL);
         *
         *   list = gtk_list_view_new (GTK_SELECTION_MODEL (gtk_single_selection_new (model)), factory);
         *
         *   g_signal_connect (list, "activate", G_CALLBACK (activate_cb), NULL);
         *
         *   gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), list);
         * ```
         *
         * # Actions
         *
         * `GtkListView` defines a set of built-in actions:
         *
         * - `list.activate-item` activates the item at given position by emitting
         *   the [signal`Gtk`.ListView::activate] signal.
         *
         * # CSS nodes
         *
         * ```
         * listview[.separators][.rich-list][.navigation-sidebar][.data-table]
         * ├── row[.activatable]
         * │
         * ├── row[.activatable]
         * │
         * ┊
         * ╰── [rubberband]
         * ```
         *
         * `GtkListView` uses a single CSS node named `listview`. It may carry the
         * `.separators` style class, when [property`Gtk`.ListView:show-separators]
         * property is set. Each child widget uses a single CSS node named `row`.
         * If the [property`Gtk`.ListItem:activatable] property is set, the
         * corresponding row will have the `.activatable` style class. For
         * rubberband selection, a node with name `rubberband` is used.
         *
         * The main listview node may also carry style classes to select
         * the style of [list presentation](ListContainers.html#list-styles):
         * .rich-list, .navigation-sidebar or .data-table.
         *
         * # Accessibility
         *
         * `GtkListView` uses the %GTK_ACCESSIBLE_ROLE_LIST role, and the list
         * items use the %GTK_ACCESSIBLE_ROLE_LIST_ITEM role.
         */
        class ListView extends ListBase implements Accessible, Buildable, ConstraintTarget, Orientable, Scrollable {
            static $gtype: GObject.GType<ListView>;

            // Properties

            /**
             * Allow rubberband selection.
             */
            get enable_rubberband(): boolean;
            set enable_rubberband(val: boolean);
            /**
             * Allow rubberband selection.
             */
            get enableRubberband(): boolean;
            set enableRubberband(val: boolean);
            /**
             * Factory for populating list items.
             *
             * The factory must be for configuring [class`Gtk`.ListItem] objects.
             */
            get factory(): ListItemFactory;
            set factory(val: ListItemFactory);
            /**
             * Factory for creating header widgets.
             *
             * The factory must be for configuring [class`Gtk`.ListHeader] objects.
             */
            get header_factory(): ListItemFactory;
            set header_factory(val: ListItemFactory);
            /**
             * Factory for creating header widgets.
             *
             * The factory must be for configuring [class`Gtk`.ListHeader] objects.
             */
            get headerFactory(): ListItemFactory;
            set headerFactory(val: ListItemFactory);
            /**
             * Model for the items displayed.
             */
            get model(): SelectionModel;
            set model(val: SelectionModel);
            /**
             * Show separators between rows.
             */
            get show_separators(): boolean;
            set show_separators(val: boolean);
            /**
             * Show separators between rows.
             */
            get showSeparators(): boolean;
            set showSeparators(val: boolean);
            /**
             * Activate rows on single click and select them on hover.
             */
            get single_click_activate(): boolean;
            set single_click_activate(val: boolean);
            /**
             * Activate rows on single click and select them on hover.
             */
            get singleClickActivate(): boolean;
            set singleClickActivate(val: boolean);
            /**
             * Behavior of the <kbd>Tab</kbd> key
             */
            get tab_behavior(): ListTabBehavior;
            set tab_behavior(val: ListTabBehavior);
            /**
             * Behavior of the <kbd>Tab</kbd> key
             */
            get tabBehavior(): ListTabBehavior;
            set tabBehavior(val: ListTabBehavior);

            // Constructors

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

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

            static ['new'](model?: SelectionModel | null, factory?: ListItemFactory | null): ListView;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate', callback: (_source: this, position: number) => void): number;
            connect_after(signal: 'activate', callback: (_source: this, position: number) => void): number;
            emit(signal: 'activate', position: number): void;

            // Methods

            /**
             * Returns whether rows can be selected by dragging with the mouse.
             * @returns %TRUE if rubberband selection is enabled
             */
            get_enable_rubberband(): boolean;
            /**
             * Gets the factory that's currently used to populate list items.
             * @returns The factory in use
             */
            get_factory(): ListItemFactory | null;
            /**
             * Gets the factory that's currently used to populate section headers.
             * @returns The factory in use
             */
            get_header_factory(): ListItemFactory | null;
            /**
             * Gets the model that's currently used to read the items displayed.
             * @returns The model in use
             */
            get_model(): SelectionModel | null;
            /**
             * Returns whether the list box should show separators
             * between rows.
             * @returns %TRUE if the list box shows separators
             */
            get_show_separators(): boolean;
            /**
             * Returns whether rows will be activated on single click and
             * selected on hover.
             * @returns %TRUE if rows are activated on single click
             */
            get_single_click_activate(): boolean;
            /**
             * Gets the behavior set for the <kbd>Tab</kbd> key.
             * @returns The behavior of the <kbd>Tab</kbd> key
             */
            get_tab_behavior(): ListTabBehavior;
            /**
             * Scrolls to the item at the given position and performs the actions
             * specified in `flags`.
             *
             * This function works no matter if the listview is shown or focused.
             * If it isn't, then the changes will take effect once that happens.
             * @param pos position of the item. Must be less than the number of   items in the view.
             * @param flags actions to perform
             * @param scroll details of how to perform   the scroll operation or %NULL to scroll into view
             */
            scroll_to(pos: number, flags: ListScrollFlags | null, scroll?: ScrollInfo | null): void;
            /**
             * Sets whether selections can be changed by dragging with the mouse.
             * @param enable_rubberband %TRUE to enable rubberband selection
             */
            set_enable_rubberband(enable_rubberband: boolean): void;
            /**
             * Sets the `GtkListItemFactory` to use for populating list items.
             * @param factory the factory to use
             */
            set_factory(factory?: ListItemFactory | null): void;
            /**
             * Sets the `GtkListItemFactory` to use for populating the
             * [class`Gtk`.ListHeader] objects used in section headers.
             *
             * If this factory is set to %NULL, the list will not show section headers.
             * @param factory the factory to use
             */
            set_header_factory(factory?: ListItemFactory | null): void;
            /**
             * Sets the model to use.
             *
             * This must be a [iface`Gtk`.SelectionModel] to use.
             * @param model the model to use
             */
            set_model(model?: SelectionModel | null): void;
            /**
             * Sets whether the list box should show separators
             * between rows.
             * @param show_separators %TRUE to show separators
             */
            set_show_separators(show_separators: boolean): void;
            /**
             * Sets whether rows should be activated on single click and
             * selected on hover.
             * @param single_click_activate %TRUE to activate items on single click
             */
            set_single_click_activate(single_click_activate: boolean): void;
            /**
             * Sets the behavior of the <kbd>Tab</kbd> and <kbd>Shift</kbd>+<kbd>Tab</kbd> keys.
             * @param tab_behavior The desired tab behavior
             */
            set_tab_behavior(tab_behavior: ListTabBehavior | null): void;

            // Inherited properties
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);
            /**
             * Horizontal `GtkAdjustment` of the scrollable widget.
             *
             * This adjustment is shared between the scrollable widget and its parent.
             */
            get hadjustment(): Adjustment;
            set hadjustment(val: Adjustment);
            /**
             * Determines when horizontal scrolling should start.
             */
            get hscroll_policy(): ScrollablePolicy;
            set hscroll_policy(val: ScrollablePolicy);
            /**
             * Determines when horizontal scrolling should start.
             */
            get hscrollPolicy(): ScrollablePolicy;
            set hscrollPolicy(val: ScrollablePolicy);
            /**
             * Vertical `GtkAdjustment` of the scrollable widget.
             *
             * This adjustment is shared between the scrollable widget and its parent.
             */
            get vadjustment(): Adjustment;
            set vadjustment(val: Adjustment);
            /**
             * Determines when vertical scrolling should start.
             */
            get vscroll_policy(): ScrollablePolicy;
            set vscroll_policy(val: ScrollablePolicy);
            /**
             * Determines when vertical scrolling should start.
             */
            get vscrollPolicy(): ScrollablePolicy;
            set vscrollPolicy(val: ScrollablePolicy);

            // Inherited methods
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Returns the size of a non-scrolling border around the
             * outside of the scrollable.
             *
             * An example for this would be treeview headers. GTK can use
             * this information to display overlaid graphics, like the
             * overshoot indication, at the right position.
             * @returns %TRUE if @border has been set
             */
            get_border(): [boolean, Border];
            /**
             * Retrieves the `GtkAdjustment` used for horizontal scrolling.
             * @returns horizontal `GtkAdjustment`.
             */
            get_hadjustment(): Adjustment | null;
            /**
             * Gets the horizontal `GtkScrollablePolicy`.
             * @returns The horizontal `GtkScrollablePolicy`.
             */
            get_hscroll_policy(): ScrollablePolicy;
            /**
             * Retrieves the `GtkAdjustment` used for vertical scrolling.
             * @returns vertical `GtkAdjustment`.
             */
            get_vadjustment(): Adjustment | null;
            /**
             * Gets the vertical `GtkScrollablePolicy`.
             * @returns The vertical `GtkScrollablePolicy`.
             */
            get_vscroll_policy(): ScrollablePolicy;
            /**
             * Sets the horizontal adjustment of the `GtkScrollable`.
             * @param hadjustment a `GtkAdjustment`
             */
            set_hadjustment(hadjustment?: Adjustment | null): void;
            /**
             * Sets the `GtkScrollablePolicy`.
             *
             * The policy determines whether horizontal scrolling should start
             * below the minimum width or below the natural width.
             * @param policy the horizontal `GtkScrollablePolicy`
             */
            set_hscroll_policy(policy: ScrollablePolicy | null): void;
            /**
             * Sets the vertical adjustment of the `GtkScrollable`.
             * @param vadjustment a `GtkAdjustment`
             */
            set_vadjustment(vadjustment?: Adjustment | null): void;
            /**
             * Sets the `GtkScrollablePolicy`.
             *
             * The policy determines whether vertical scrolling should start
             * below the minimum height or below the natural height.
             * @param policy the vertical `GtkScrollablePolicy`
             */
            set_vscroll_policy(policy: ScrollablePolicy | null): void;
            /**
             * Returns the size of a non-scrolling border around the
             * outside of the scrollable.
             *
             * An example for this would be treeview headers. GTK can use
             * this information to display overlaid graphics, like the
             * overshoot indication, at the right position.
             */
            vfunc_get_border(): [boolean, Border];
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace LockButton {
            // Constructor properties interface

            interface ConstructorProps
                extends Button.ConstructorProps,
                    Accessible.ConstructorProps,
                    Actionable.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                permission: Gio.Permission;
                text_lock: string;
                textLock: string;
                text_unlock: string;
                textUnlock: string;
                tooltip_lock: string;
                tooltipLock: string;
                tooltip_not_authorized: string;
                tooltipNotAuthorized: string;
                tooltip_unlock: string;
                tooltipUnlock: string;
            }
        }

        /**
         * `GtkLockButton` is a widget to obtain and revoke authorizations
         * needed to operate the controls.
         *
         * ![An example GtkLockButton](lock-button.png)
         *
         * It is typically used in preference dialogs or control panels.
         *
         * The required authorization is represented by a `GPermission` object.
         * Concrete implementations of `GPermission` may use PolicyKit or some
         * other authorization framework. To obtain a PolicyKit-based
         * `GPermission`, use `polkit_permission_new()`.
         *
         * If the user is not currently allowed to perform the action, but can
         * obtain the permission, the widget looks like this:
         *
         * ![](lockbutton-locked.png)
         *
         * and the user can click the button to request the permission. Depending
         * on the platform, this may pop up an authentication dialog or ask the user
         * to authenticate in some other way. Once the user has obtained the permission,
         * the widget changes to this:
         *
         * ![](lockbutton-unlocked.png)
         *
         * and the permission can be dropped again by clicking the button. If the user
         * is not able to obtain the permission at all, the widget looks like this:
         *
         * ![](lockbutton-sorry.png)
         *
         * If the user has the permission and cannot drop it, the button is hidden.
         *
         * The text (and tooltips) that are shown in the various cases can be adjusted
         * with the [property`Gtk`.LockButton:text-lock],
         * [property`Gtk`.LockButton:text-unlock],
         * [property`Gtk`.LockButton:tooltip-lock],
         * [property`Gtk`.LockButton:tooltip-unlock] and
         * [property`Gtk`.LockButton:tooltip-not-authorized] properties.
         */
        class LockButton extends Button implements Accessible, Actionable, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<LockButton>;

            // Properties

            /**
             * The `GPermission object controlling this button.
             */
            get permission(): Gio.Permission;
            set permission(val: Gio.Permission);
            /**
             * The text to display when prompting the user to lock.
             */
            get text_lock(): string;
            set text_lock(val: string);
            /**
             * The text to display when prompting the user to lock.
             */
            get textLock(): string;
            set textLock(val: string);
            /**
             * The text to display when prompting the user to unlock.
             */
            get text_unlock(): string;
            set text_unlock(val: string);
            /**
             * The text to display when prompting the user to unlock.
             */
            get textUnlock(): string;
            set textUnlock(val: string);
            /**
             * The tooltip to display when prompting the user to lock.
             */
            get tooltip_lock(): string;
            set tooltip_lock(val: string);
            /**
             * The tooltip to display when prompting the user to lock.
             */
            get tooltipLock(): string;
            set tooltipLock(val: string);
            /**
             * The tooltip to display when the user cannot obtain authorization.
             */
            get tooltip_not_authorized(): string;
            set tooltip_not_authorized(val: string);
            /**
             * The tooltip to display when the user cannot obtain authorization.
             */
            get tooltipNotAuthorized(): string;
            set tooltipNotAuthorized(val: string);
            /**
             * The tooltip to display when prompting the user to unlock.
             */
            get tooltip_unlock(): string;
            set tooltip_unlock(val: string);
            /**
             * The tooltip to display when prompting the user to unlock.
             */
            get tooltipUnlock(): string;
            set tooltipUnlock(val: string);

            // Constructors

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

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

            static ['new'](permission?: Gio.Permission | null): LockButton;
            // Conflicted with Gtk.Button.new

            static ['new'](...args: never[]): any;

            // Methods

            /**
             * Obtains the `GPermission` object that controls `button`.
             * @returns the `GPermission` of @button
             */
            get_permission(): Gio.Permission | null;
            /**
             * Sets the `GPermission` object that controls `button`.
             * @param permission a `GPermission` object
             */
            set_permission(permission?: Gio.Permission | null): void;

            // Inherited properties
            /**
             * The name of the action with which this widget should be associated.
             */
            get action_name(): string;
            set action_name(val: string);
            /**
             * The name of the action with which this widget should be associated.
             */
            get actionName(): string;
            set actionName(val: string);
            /**
             * The target value of the actionable widget's action.
             */
            get action_target(): GLib.Variant;
            set action_target(val: GLib.Variant);
            /**
             * The target value of the actionable widget's action.
             */
            get actionTarget(): GLib.Variant;
            set actionTarget(val: GLib.Variant);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Gets the action name for `actionable`.
             * @returns the action name
             */
            get_action_name(): string | null;
            /**
             * Gets the current target value of `actionable`.
             * @returns the current target value
             */
            get_action_target_value(): GLib.Variant | null;
            /**
             * Specifies the name of the action with which this widget should be
             * associated.
             *
             * If `action_name` is %NULL then the widget will be unassociated from
             * any previous action.
             *
             * Usually this function is used when the widget is located (or will be
             * located) within the hierarchy of a `GtkApplicationWindow`.
             *
             * Names are of the form “win.save” or “app.quit” for actions on the
             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
             * associated with the window.
             * @param action_name an action name
             */
            set_action_name(action_name?: string | null): void;
            /**
             * Sets the target value of an actionable widget.
             *
             * If `target_value` is %NULL then the target value is unset.
             *
             * The target value has two purposes. First, it is used as the parameter
             * to activation of the action associated with the `GtkActionable` widget.
             * Second, it is used to determine if the widget should be rendered as
             * “active” — the widget is active if the state is equal to the given target.
             *
             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
             * with string state in a typical “radio button” situation. Each button
             * will be associated with the same action, but with a different target
             * value for that action. Clicking on a particular button will activate
             * the action with the target of that button, which will typically cause
             * the action’s state to change to that value. Since the action’s state
             * is now equal to the target value of the button, the button will now
             * be rendered as active (and the other buttons, with different targets,
             * rendered inactive).
             * @param target_value a [struct@GLib.Variant] to set as the target value
             */
            set_action_target_value(target_value?: GLib.Variant | null): void;
            /**
             * Sets the action-name and associated string target value of an
             * actionable widget.
             *
             * `detailed_action_name` is a string in the format accepted by
             * [func`Gio`.Action.parse_detailed_name].
             * @param detailed_action_name the detailed action name
             */
            set_detailed_action_name(detailed_action_name: string): void;
            /**
             * Gets the action name for `actionable`.
             */
            vfunc_get_action_name(): string | null;
            /**
             * Gets the current target value of `actionable`.
             */
            vfunc_get_action_target_value(): GLib.Variant | null;
            /**
             * Specifies the name of the action with which this widget should be
             * associated.
             *
             * If `action_name` is %NULL then the widget will be unassociated from
             * any previous action.
             *
             * Usually this function is used when the widget is located (or will be
             * located) within the hierarchy of a `GtkApplicationWindow`.
             *
             * Names are of the form “win.save” or “app.quit” for actions on the
             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
             * associated with the window.
             * @param action_name an action name
             */
            vfunc_set_action_name(action_name?: string | null): void;
            /**
             * Sets the target value of an actionable widget.
             *
             * If `target_value` is %NULL then the target value is unset.
             *
             * The target value has two purposes. First, it is used as the parameter
             * to activation of the action associated with the `GtkActionable` widget.
             * Second, it is used to determine if the widget should be rendered as
             * “active” — the widget is active if the state is equal to the given target.
             *
             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
             * with string state in a typical “radio button” situation. Each button
             * will be associated with the same action, but with a different target
             * value for that action. Clicking on a particular button will activate
             * the action with the target of that button, which will typically cause
             * the action’s state to change to that value. Since the action’s state
             * is now equal to the target value of the button, the button will now
             * be rendered as active (and the other buttons, with different targets,
             * rendered inactive).
             * @param target_value a [struct@GLib.Variant] to set as the target value
             */
            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace MapListModel {
            // Constructor properties interface

            interface ConstructorProps<A extends GObject.Object = GObject.Object>
                extends GObject.Object.ConstructorProps,
                    Gio.ListModel.ConstructorProps,
                    SectionModel.ConstructorProps {
                has_map: boolean;
                hasMap: boolean;
                item_type: GObject.GType;
                itemType: GObject.GType;
                model: Gio.ListModel;
                n_items: number;
                nItems: number;
            }
        }

        /**
         * A `GtkMapListModel` maps the items in a list model to different items.
         *
         * `GtkMapListModel` uses a [callback`Gtk`.MapListModelMapFunc].
         *
         * Example: Create a list of `GtkEventControllers`
         * ```c
         * static gpointer
         * map_to_controllers (gpointer widget,
         *                     gpointer data)
         * {
         *   gpointer result = gtk_widget_observe_controllers (widget);
         *   g_object_unref (widget);
         *   return result;
         * }
         *
         * widgets = gtk_widget_observe_children (widget);
         *
         * controllers = gtk_map_list_model_new (widgets,
         *                                       map_to_controllers,
         *                                       NULL, NULL);
         *
         * model = gtk_flatten_list_model_new (GTK_TYPE_EVENT_CONTROLLER,
         *                                     controllers);
         * ```
         *
         * `GtkMapListModel` will attempt to discard the mapped objects as soon as
         * they are no longer needed and recreate them if necessary.
         *
         * `GtkMapListModel` passes through sections from the underlying model.
         */
        class MapListModel<A extends GObject.Object = GObject.Object>
            extends GObject.Object
            implements Gio.ListModel<A>, SectionModel
        {
            static $gtype: GObject.GType<MapListModel>;

            // Properties

            /**
             * If a map is set for this model
             */
            get has_map(): boolean;
            /**
             * If a map is set for this model
             */
            get hasMap(): boolean;
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get item_type(): GObject.GType;
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get itemType(): GObject.GType;
            /**
             * The model being mapped.
             */
            get model(): Gio.ListModel;
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get n_items(): number;
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get nItems(): number;

            // Constructors

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

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

            static ['new'](model?: Gio.ListModel | null, map_func?: MapListModelMapFunc | null): MapListModel;

            // Methods

            /**
             * Gets the model that is currently being mapped or %NULL if none.
             * @returns The model that gets mapped
             */
            get_model(): Gio.ListModel | null;
            /**
             * Sets the function used to map items.
             *
             * The function will be called whenever an item needs to be mapped
             * and must return the item to use for the given input item.
             *
             * Note that `GtkMapListModel` may call this function multiple times
             * on the same item, because it may delete items it doesn't need anymore.
             *
             * GTK makes no effort to ensure that `map_func` conforms to the item type
             * of `self`. It assumes that the caller knows what they are doing and the map
             * function returns items of the appropriate type.
             * @param map_func map function
             */
            set_map_func(map_func?: MapListModelMapFunc | null): void;
            /**
             * Sets the model to be mapped.
             *
             * GTK makes no effort to ensure that `model` conforms to the item type
             * expected by the map function. It assumes that the caller knows what
             * they are doing and have set up an appropriate map function.
             * @param model The model to be mapped
             */
            set_model(model?: Gio.ListModel | null): void;

            // Inherited methods
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             * @returns the #GType of the items contained in @list.
             */
            get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             * @returns the number of items in @list.
             */
            get_n_items(): number;
            /**
             * Get the item at `position`.
             *
             * If `position` is greater than the number of items in `list,` %NULL is
             * returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.
             *
             * This function is meant to be used by language bindings in place
             * of g_list_model_get_item().
             *
             * See also: g_list_model_get_n_items()
             * @param position the position of the item to fetch
             * @returns the object at @position.
             */
            get_item(position: number): A | null;
            /**
             * Emits the #GListModel::items-changed signal on `list`.
             *
             * This function should only be called by classes implementing
             * #GListModel. It has to be called after the internal representation
             * of `list` has been updated, because handlers connected to this signal
             * might query the new state of the list.
             *
             * Implementations must only make changes to the model (as visible to
             * its consumer) in places that will not cause problems for that
             * consumer.  For models that are driven directly by a write API (such
             * as #GListStore), changes can be reported in response to uses of that
             * API.  For models that represent remote data, changes should only be
             * made from a fresh mainloop dispatch.  It is particularly not
             * permitted to make changes in response to a call to the #GListModel
             * consumer API.
             *
             * Stated another way: in general, it is assumed that code making a
             * series of accesses to the model via the API, without returning to the
             * mainloop, and without calling other code, will continue to view the
             * same contents of the model.
             * @param position the position at which @list changed
             * @param removed the number of items removed
             * @param added the number of items added
             */
            items_changed(position: number, removed: number, added: number): void;
            /**
             * Get the item at `position`. If `position` is greater than the number of
             * items in `list,` %NULL is returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.  See g_list_model_get_n_items().
             *
             * The same #GObject instance may not appear more than once in a #GListModel.
             * @param position the position of the item to fetch
             */
            vfunc_get_item(position: number): A | null;
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             */
            vfunc_get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             */
            vfunc_get_n_items(): number;
            /**
             * Query the section that covers the given position. The number of
             * items in the section can be computed by `out_end - out_start`.
             *
             * If the position is larger than the number of items, a single
             * range from n_items to G_MAXUINT will be returned.
             * @param position the position of the item to query
             */
            get_section(position: number): [number, number];
            /**
             * This function emits the [signal`Gtk`.SectionModel::sections-changed]
             * signal to notify about changes to sections.
             *
             * It must cover all positions that used to be a section start or that
             * are now a section start. It does not have to cover all positions for
             * which the section has changed.
             *
             * The [signal`Gio`.ListModel::items-changed] implies the effect of the
             * [signal`Gtk`.SectionModel::sections-changed] signal for all the items
             * it covers.
             *
             * It is recommended that when changes to the items cause section changes
             * in a larger range, that the larger range is included in the emission
             * of the [signal`Gio`.ListModel::items-changed] instead of emitting
             * two signals.
             * @param position the first changed item
             * @param n_items the number of changed items
             */
            sections_changed(position: number, n_items: number): void;
            /**
             * Query the section that covers the given position. The number of
             * items in the section can be computed by `out_end - out_start`.
             *
             * If the position is larger than the number of items, a single
             * range from n_items to G_MAXUINT will be returned.
             * @param position the position of the item to query
             */
            vfunc_get_section(position: number): [number, number];
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace MediaControls {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                media_stream: MediaStream;
                mediaStream: MediaStream;
            }
        }

        /**
         * `GtkMediaControls` is a widget to show controls for a video.
         *
         * ![An example GtkMediaControls](media-controls.png)
         *
         * Usually, `GtkMediaControls` is used as part of [class`Gtk`.Video].
         */
        class MediaControls extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<MediaControls>;

            // Properties

            /**
             * The media-stream managed by this object or %NULL if none.
             */
            get media_stream(): MediaStream;
            set media_stream(val: MediaStream);
            /**
             * The media-stream managed by this object or %NULL if none.
             */
            get mediaStream(): MediaStream;
            set mediaStream(val: MediaStream);

            // Constructors

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

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

            static ['new'](stream?: MediaStream | null): MediaControls;

            // Methods

            /**
             * Gets the media stream managed by `controls` or %NULL if none.
             * @returns The media stream managed by @controls
             */
            get_media_stream(): MediaStream | null;
            /**
             * Sets the stream that is controlled by `controls`.
             * @param stream a `GtkMediaStream`
             */
            set_media_stream(stream?: MediaStream | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace MediaFile {
            // Constructor properties interface

            interface ConstructorProps extends MediaStream.ConstructorProps, Gdk.Paintable.ConstructorProps {
                file: Gio.File;
                input_stream: Gio.InputStream;
                inputStream: Gio.InputStream;
            }
        }

        /**
         * `GtkMediaFile` implements `GtkMediaStream` for files.
         *
         * This provides a simple way to play back video files with GTK.
         *
         * GTK provides a GIO extension point for `GtkMediaFile` implementations
         * to allow for external implementations using various media frameworks.
         *
         * GTK itself includes an implementation using GStreamer.
         */
        abstract class MediaFile extends MediaStream implements Gdk.Paintable {
            static $gtype: GObject.GType<MediaFile>;

            // Properties

            /**
             * The file being played back or %NULL if not playing a file.
             */
            get file(): Gio.File;
            set file(val: Gio.File);
            /**
             * The stream being played back or %NULL if not playing a stream.
             *
             * This is %NULL when playing a file.
             */
            get input_stream(): Gio.InputStream;
            set input_stream(val: Gio.InputStream);
            /**
             * The stream being played back or %NULL if not playing a stream.
             *
             * This is %NULL when playing a file.
             */
            get inputStream(): Gio.InputStream;
            set inputStream(val: Gio.InputStream);

            // Constructors

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

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

            static ['new'](): MediaFile;

            static new_for_file(file: Gio.File): MediaFile;

            static new_for_filename(filename: string): MediaFile;

            static new_for_input_stream(stream: Gio.InputStream): MediaFile;

            static new_for_resource(resource_path: string): MediaFile;

            // Virtual methods

            vfunc_close(): void;
            vfunc_open(): void;

            // Methods

            /**
             * Resets the media file to be empty.
             */
            clear(): void;
            /**
             * Returns the file that `self` is currently playing from.
             *
             * When `self` is not playing or not playing from a file,
             * %NULL is returned.
             * @returns The currently playing file
             */
            get_file(): Gio.File | null;
            /**
             * Returns the stream that `self` is currently playing from.
             *
             * When `self` is not playing or not playing from a stream,
             * %NULL is returned.
             * @returns The currently playing stream
             */
            get_input_stream(): Gio.InputStream | null;
            /**
             * Sets the `GtkMediaFile` to play the given file.
             *
             * If any file is still playing, stop playing it.
             * @param file the file to play
             */
            set_file(file?: Gio.File | null): void;
            /**
             * Sets the `GtkMediaFile to play the given file.
             *
             * This is a utility function that converts the given `filename`
             * to a `GFile` and calls [method`Gtk`.MediaFile.set_file].
             * @param filename name of file to play
             */
            set_filename(filename?: string | null): void;
            /**
             * Sets the `GtkMediaFile` to play the given stream.
             *
             * If anything is still playing, stop playing it.
             *
             * Full control about the `stream` is assumed for the duration of
             * playback. The stream will not be closed.
             * @param stream the stream to play from
             */
            set_input_stream(stream?: Gio.InputStream | null): void;
            /**
             * Sets the `GtkMediaFile to play the given resource.
             *
             * This is a utility function that converts the given `resource_path`
             * to a `GFile` and calls [method`Gtk`.MediaFile.set_file].
             * @param resource_path path to resource to play
             */
            set_resource(resource_path?: string | null): void;

            // Inherited methods
            /**
             * Compute a concrete size for the `GdkPaintable`.
             *
             * Applies the sizing algorithm outlined in the
             * [CSS Image spec](https://drafts.csswg.org/css-images-3/#default-sizing)
             * to the given `paintable`. See that link for more details.
             *
             * It is not necessary to call this function when both `specified_width`
             * and `specified_height` are known, but it is useful to call this
             * function in GtkWidget:measure implementations to compute the
             * other dimension when only one dimension is given.
             * @param specified_width the width @paintable could be drawn into or   0.0 if unknown
             * @param specified_height the height @paintable could be drawn into or   0.0 if unknown
             * @param default_width the width @paintable would be drawn into if   no other constraints were given
             * @param default_height the height @paintable would be drawn into if   no other constraints were given
             */
            compute_concrete_size(
                specified_width: number,
                specified_height: number,
                default_width: number,
                default_height: number,
            ): [number, number];
            /**
             * Gets an immutable paintable for the current contents displayed by `paintable`.
             *
             * This is useful when you want to retain the current state of an animation,
             * for example to take a screenshot of a running animation.
             *
             * If the `paintable` is already immutable, it will return itself.
             * @returns An immutable paintable for the current   contents of @paintable
             */
            get_current_image(): Gdk.Paintable;
            /**
             * Get flags for the paintable.
             *
             * This is oftentimes useful for optimizations.
             *
             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
             * @returns The `GdkPaintableFlags` for this paintable
             */
            get_flags(): Gdk.PaintableFlags;
            /**
             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
             *
             * The aspect ratio is the width divided by the height, so a value of 0.5
             * means that the `paintable` prefers to be displayed twice as high as it
             * is wide. Consumers of this interface can use this to preserve aspect
             * ratio when displaying the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * Usually when a `paintable` returns nonzero values from
             * [method`Gdk`.Paintable.get_intrinsic_width] and
             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
             * should conform to those values, though that is not required.
             *
             * If the `paintable` does not have a preferred aspect ratio,
             * it returns 0. Negative values are never returned.
             * @returns the intrinsic aspect ratio of @paintable or 0 if none.
             */
            get_intrinsic_aspect_ratio(): number;
            /**
             * Gets the preferred height the `paintable` would like to be displayed at.
             *
             * Consumers of this interface can use this to reserve enough space to draw
             * the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * If the `paintable` does not have a preferred height, it returns 0.
             * Negative values are never returned.
             * @returns the intrinsic height of @paintable or 0 if none.
             */
            get_intrinsic_height(): number;
            /**
             * Gets the preferred width the `paintable` would like to be displayed at.
             *
             * Consumers of this interface can use this to reserve enough space to draw
             * the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * If the `paintable` does not have a preferred width, it returns 0.
             * Negative values are never returned.
             * @returns the intrinsic width of @paintable or 0 if none.
             */
            get_intrinsic_width(): number;
            /**
             * Called by implementations of `GdkPaintable` to invalidate their contents.
             *
             * Unless the contents are invalidated, implementations must guarantee that
             * multiple calls of [method`Gdk`.Paintable.snapshot] produce the same output.
             *
             * This function will emit the [signal`Gdk`.Paintable::invalidate-contents]
             * signal.
             *
             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_CONTENTS flag,
             * it must not call this function.
             */
            invalidate_contents(): void;
            /**
             * Called by implementations of `GdkPaintable` to invalidate their size.
             *
             * As long as the size is not invalidated, `paintable` must return the same
             * values for its intrinsic width, height and aspect ratio.
             *
             * This function will emit the [signal`Gdk`.Paintable::invalidate-size]
             * signal.
             *
             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_SIZE flag,
             * it must not call this function.
             */
            invalidate_size(): void;
            /**
             * Snapshots the given paintable with the given `width` and `height`.
             *
             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
             * If `width` and `height` are not larger than zero, this function will
             * do nothing.
             * @param snapshot a `GdkSnapshot` to snapshot to
             * @param width width to snapshot in
             * @param height height to snapshot in
             */
            snapshot(snapshot: Gdk.Snapshot, width: number, height: number): void;
            /**
             * Gets an immutable paintable for the current contents displayed by `paintable`.
             *
             * This is useful when you want to retain the current state of an animation,
             * for example to take a screenshot of a running animation.
             *
             * If the `paintable` is already immutable, it will return itself.
             */
            vfunc_get_current_image(): Gdk.Paintable;
            /**
             * Get flags for the paintable.
             *
             * This is oftentimes useful for optimizations.
             *
             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
             */
            vfunc_get_flags(): Gdk.PaintableFlags;
            /**
             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
             *
             * The aspect ratio is the width divided by the height, so a value of 0.5
             * means that the `paintable` prefers to be displayed twice as high as it
             * is wide. Consumers of this interface can use this to preserve aspect
             * ratio when displaying the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * Usually when a `paintable` returns nonzero values from
             * [method`Gdk`.Paintable.get_intrinsic_width] and
             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
             * should conform to those values, though that is not required.
             *
             * If the `paintable` does not have a preferred aspect ratio,
             * it returns 0. Negative values are never returned.
             */
            vfunc_get_intrinsic_aspect_ratio(): number;
            /**
             * Gets the preferred height the `paintable` would like to be displayed at.
             *
             * Consumers of this interface can use this to reserve enough space to draw
             * the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * If the `paintable` does not have a preferred height, it returns 0.
             * Negative values are never returned.
             */
            vfunc_get_intrinsic_height(): number;
            /**
             * Gets the preferred width the `paintable` would like to be displayed at.
             *
             * Consumers of this interface can use this to reserve enough space to draw
             * the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * If the `paintable` does not have a preferred width, it returns 0.
             * Negative values are never returned.
             */
            vfunc_get_intrinsic_width(): number;
            /**
             * Snapshots the given paintable with the given `width` and `height`.
             *
             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
             * If `width` and `height` are not larger than zero, this function will
             * do nothing.
             * @param snapshot a `GdkSnapshot` to snapshot to
             * @param width width to snapshot in
             * @param height height to snapshot in
             */
            vfunc_snapshot(snapshot: Gdk.Snapshot, width: number, height: number): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace MediaStream {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps, Gdk.Paintable.ConstructorProps {
                duration: number;
                ended: boolean;
                error: GLib.Error;
                has_audio: boolean;
                hasAudio: boolean;
                has_video: boolean;
                hasVideo: boolean;
                loop: boolean;
                muted: boolean;
                playing: boolean;
                prepared: boolean;
                seekable: boolean;
                seeking: boolean;
                timestamp: number;
                volume: number;
            }
        }

        /**
         * `GtkMediaStream` is the integration point for media playback inside GTK.
         *
         * GTK provides an implementation of the `GtkMediaStream` interface that
         * is called [class`Gtk`.MediaFile].
         *
         * Apart from application-facing API for stream playback, `GtkMediaStream`
         * has a number of APIs that are only useful for implementations and should
         * not be used in applications:
         * [method`Gtk`.MediaStream.prepared],
         * [method`Gtk`.MediaStream.unprepared],
         * [method`Gtk`.MediaStream.update],
         * [method`Gtk`.MediaStream.ended],
         * [method`Gtk`.MediaStream.seek_success],
         * [method`Gtk`.MediaStream.seek_failed],
         * [method`Gtk`.MediaStream.gerror],
         * [method`Gtk`.MediaStream.error],
         * [method`Gtk`.MediaStream.error_valist].
         */
        abstract class MediaStream extends GObject.Object implements Gdk.Paintable {
            static $gtype: GObject.GType<MediaStream>;

            // Properties

            /**
             * The stream's duration in microseconds or 0 if unknown.
             */
            get duration(): number;
            /**
             * Set when playback has finished.
             */
            get ended(): boolean;
            /**
             * %NULL for a properly working stream or the `GError`
             * that the stream is in.
             */
            get error(): GLib.Error;
            /**
             * Whether the stream contains audio.
             */
            get has_audio(): boolean;
            /**
             * Whether the stream contains audio.
             */
            get hasAudio(): boolean;
            /**
             * Whether the stream contains video.
             */
            get has_video(): boolean;
            /**
             * Whether the stream contains video.
             */
            get hasVideo(): boolean;
            /**
             * Try to restart the media from the beginning once it ended.
             */
            get loop(): boolean;
            set loop(val: boolean);
            /**
             * Whether the audio stream should be muted.
             */
            get muted(): boolean;
            set muted(val: boolean);
            /**
             * Whether the stream is currently playing.
             */
            get playing(): boolean;
            set playing(val: boolean);
            /**
             * Whether the stream has finished initializing and existence of
             * audio and video is known.
             */
            get prepared(): boolean;
            set prepared(val: boolean);
            /**
             * Set unless the stream is known to not support seeking.
             */
            get seekable(): boolean;
            /**
             * Set while a seek is in progress.
             */
            get seeking(): boolean;
            /**
             * The current presentation timestamp in microseconds.
             */
            get timestamp(): number;
            /**
             * Volume of the audio stream.
             */
            get volume(): number;
            set volume(val: number);

            // Constructors

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

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

            // Virtual methods

            /**
             * Pauses playback of the stream.
             *
             * If the stream is not playing, do nothing.
             */
            vfunc_pause(): void;
            vfunc_play(): boolean;
            /**
             * Called by users to attach the media stream to a `GdkSurface` they manage.
             *
             * The stream can then access the resources of `surface` for its
             * rendering purposes. In particular, media streams might want to
             * create a `GdkGLContext` or sync to the `GdkFrameClock`.
             *
             * Whoever calls this function is responsible for calling
             * [method`Gtk`.MediaStream.unrealize] before either the stream
             * or `surface` get destroyed.
             *
             * Multiple calls to this function may happen from different
             * users of the video, even with the same `surface`. Each of these
             * calls must be followed by its own call to
             * [method`Gtk`.MediaStream.unrealize].
             *
             * It is not required to call this function to make a media stream work.
             * @param surface a `GdkSurface`
             */
            vfunc_realize(surface: Gdk.Surface): void;
            /**
             * Start a seek operation on `self` to `timestamp`.
             *
             * If `timestamp` is out of range, it will be clamped.
             *
             * Seek operations may not finish instantly. While a
             * seek operation is in process, the [property`Gtk`.MediaStream:seeking]
             * property will be set.
             *
             * When calling gtk_media_stream_seek() during an
             * ongoing seek operation, the new seek will override
             * any pending seek.
             * @param timestamp timestamp to seek to.
             */
            vfunc_seek(timestamp: number): void;
            /**
             * Undoes a previous call to gtk_media_stream_realize().
             *
             * This causes the stream to release all resources it had
             * allocated from `surface`.
             * @param surface the `GdkSurface` the stream was realized with
             */
            vfunc_unrealize(surface: Gdk.Surface): void;
            vfunc_update_audio(muted: boolean, volume: number): void;

            // Methods

            /**
             * Sets `self` into an error state.
             *
             * This will pause the stream (you can check for an error
             * via [method`Gtk`.MediaStream.get_error] in your
             * GtkMediaStream.pause() implementation), abort pending
             * seeks and mark the stream as prepared.
             *
             * if the stream is already in an error state, this call
             * will be ignored and the existing error will be retained.
             *
             * To unset an error, the stream must be reset via a call to
             * [method`Gtk`.MediaStream.unprepared].
             * @param error the `GError` to set
             */
            gerror(error: GLib.Error): void;
            /**
             * Gets the duration of the stream.
             *
             * If the duration is not known, 0 will be returned.
             * @returns the duration of the stream or 0 if not known.
             */
            get_duration(): number;
            /**
             * Returns whether the streams playback is finished.
             * @returns %TRUE if playback is finished
             */
            get_ended(): boolean;
            /**
             * If the stream is in an error state, returns the `GError`
             * explaining that state.
             *
             * Any type of error can be reported here depending on the
             * implementation of the media stream.
             *
             * A media stream in an error cannot be operated on, calls
             * like [method`Gtk`.MediaStream.play] or
             * [method`Gtk`.MediaStream.seek] will not have any effect.
             *
             * `GtkMediaStream` itself does not provide a way to unset
             * an error, but implementations may provide options. For example,
             * a [class`Gtk`.MediaFile] will unset errors when a new source is
             * set, e.g. with [method`Gtk`.MediaFile.set_file].
             * @returns %NULL if not in an   error state or the `GError` of the stream
             */
            get_error(): GLib.Error | null;
            /**
             * Returns whether the stream is set to loop.
             *
             * See [method`Gtk`.MediaStream.set_loop] for details.
             * @returns %TRUE if the stream should loop
             */
            get_loop(): boolean;
            /**
             * Returns whether the audio for the stream is muted.
             *
             * See [method`Gtk`.MediaStream.set_muted] for details.
             * @returns %TRUE if the stream is muted
             */
            get_muted(): boolean;
            /**
             * Return whether the stream is currently playing.
             * @returns %TRUE if the stream is playing
             */
            get_playing(): boolean;
            /**
             * Returns the current presentation timestamp in microseconds.
             * @returns the timestamp in microseconds
             */
            get_timestamp(): number;
            /**
             * Returns the volume of the audio for the stream.
             *
             * See [method`Gtk`.MediaStream.set_volume] for details.
             * @returns volume of the stream from 0.0 to 1.0
             */
            get_volume(): number;
            /**
             * Returns whether the stream has finished initializing.
             *
             * At this point the existence of audio and video is known.
             * @returns %TRUE if the stream is prepared
             */
            is_prepared(): boolean;
            /**
             * Checks if a stream may be seekable.
             *
             * This is meant to be a hint. Streams may not allow seeking even if
             * this function returns %TRUE. However, if this function returns
             * %FALSE, streams are guaranteed to not be seekable and user interfaces
             * may hide controls that allow seeking.
             *
             * It is allowed to call [method`Gtk`.MediaStream.seek] on a non-seekable
             * stream, though it will not do anything.
             * @returns %TRUE if the stream may support seeking
             */
            is_seekable(): boolean;
            /**
             * Checks if there is currently a seek operation going on.
             * @returns %TRUE if a seek operation is ongoing.
             */
            is_seeking(): boolean;
            /**
             * Pauses playback of the stream.
             *
             * If the stream is not playing, do nothing.
             */
            pause(): void;
            /**
             * Starts playing the stream.
             *
             * If the stream is in error or already playing, do nothing.
             */
            play(): void;
            /**
             * Called by users to attach the media stream to a `GdkSurface` they manage.
             *
             * The stream can then access the resources of `surface` for its
             * rendering purposes. In particular, media streams might want to
             * create a `GdkGLContext` or sync to the `GdkFrameClock`.
             *
             * Whoever calls this function is responsible for calling
             * [method`Gtk`.MediaStream.unrealize] before either the stream
             * or `surface` get destroyed.
             *
             * Multiple calls to this function may happen from different
             * users of the video, even with the same `surface`. Each of these
             * calls must be followed by its own call to
             * [method`Gtk`.MediaStream.unrealize].
             *
             * It is not required to call this function to make a media stream work.
             * @param surface a `GdkSurface`
             */
            realize(surface: Gdk.Surface): void;
            /**
             * Start a seek operation on `self` to `timestamp`.
             *
             * If `timestamp` is out of range, it will be clamped.
             *
             * Seek operations may not finish instantly. While a
             * seek operation is in process, the [property`Gtk`.MediaStream:seeking]
             * property will be set.
             *
             * When calling gtk_media_stream_seek() during an
             * ongoing seek operation, the new seek will override
             * any pending seek.
             * @param timestamp timestamp to seek to.
             */
            seek(timestamp: number): void;
            /**
             * Ends a seek operation started via GtkMediaStream.seek() as a failure.
             *
             * This will not cause an error on the stream and will assume that
             * playback continues as if no seek had happened.
             *
             * See [method`Gtk`.MediaStream.seek_success] for the other way of
             * ending a seek.
             */
            seek_failed(): void;
            /**
             * Ends a seek operation started via GtkMediaStream.seek() successfully.
             *
             * This function will unset the GtkMediaStream:ended property
             * if it was set.
             *
             * See [method`Gtk`.MediaStream.seek_failed] for the other way of
             * ending a seek.
             */
            seek_success(): void;
            /**
             * Sets whether the stream should loop.
             *
             * In this case, it will attempt to restart playback
             * from the beginning instead of stopping at the end.
             *
             * Not all streams may support looping, in particular
             * non-seekable streams. Those streams will ignore the
             * loop setting and just end.
             * @param loop %TRUE if the stream should loop
             */
            set_loop(loop: boolean): void;
            /**
             * Sets whether the audio stream should be muted.
             *
             * Muting a stream will cause no audio to be played, but it
             * does not modify the volume. This means that muting and
             * then unmuting the stream will restore the volume settings.
             *
             * If the stream has no audio, calling this function will
             * still work but it will not have an audible effect.
             * @param muted %TRUE if the stream should be muted
             */
            set_muted(muted: boolean): void;
            /**
             * Starts or pauses playback of the stream.
             * @param playing whether to start or pause playback
             */
            set_playing(playing: boolean): void;
            /**
             * Sets the volume of the audio stream.
             *
             * This function call will work even if the stream is muted.
             *
             * The given `volume` should range from 0.0 for silence to 1.0
             * for as loud as possible. Values outside of this range will
             * be clamped to the nearest value.
             *
             * If the stream has no audio or is muted, calling this function
             * will still work but it will not have an immediate audible effect.
             * When the stream is unmuted, the new volume setting will take effect.
             * @param volume New volume of the stream from 0.0 to 1.0
             */
            set_volume(volume: number): void;
            /**
             * Pauses the media stream and marks it as ended.
             *
             * This is a hint only, calls to [method`Gtk`.MediaStream.play]
             * may still happen.
             *
             * The media stream must be prepared when this function is called.
             */
            stream_ended(): void;
            /**
             * Called by `GtkMediaStream` implementations to advertise the stream
             * being ready to play and providing details about the stream.
             *
             * Note that the arguments are hints. If the stream implementation
             * cannot determine the correct values, it is better to err on the
             * side of caution and return %TRUE. User interfaces will use those
             * values to determine what controls to show.
             *
             * This function may not be called again until the stream has been
             * reset via [method`Gtk`.MediaStream.stream_unprepared].
             * @param has_audio %TRUE if the stream should advertise audio support
             * @param has_video %TRUE if the stream should advertise video support
             * @param seekable %TRUE if the stream should advertise seekability
             * @param duration The duration of the stream or 0 if unknown
             */
            stream_prepared(has_audio: boolean, has_video: boolean, seekable: boolean, duration: number): void;
            /**
             * Resets a given media stream implementation.
             *
             * [method`Gtk`.MediaStream.stream_prepared] can then be called again.
             *
             * This function will also reset any error state the stream was in.
             */
            stream_unprepared(): void;
            /**
             * Undoes a previous call to gtk_media_stream_realize().
             *
             * This causes the stream to release all resources it had
             * allocated from `surface`.
             * @param surface the `GdkSurface` the stream was realized with
             */
            unrealize(surface: Gdk.Surface): void;
            /**
             * Media stream implementations should regularly call this
             * function to update the timestamp reported by the stream.
             *
             * It is up to implementations to call this at the frequency
             * they deem appropriate.
             *
             * The media stream must be prepared when this function is called.
             * @param timestamp the new timestamp
             */
            update(timestamp: number): void;

            // Inherited methods
            /**
             * Compute a concrete size for the `GdkPaintable`.
             *
             * Applies the sizing algorithm outlined in the
             * [CSS Image spec](https://drafts.csswg.org/css-images-3/#default-sizing)
             * to the given `paintable`. See that link for more details.
             *
             * It is not necessary to call this function when both `specified_width`
             * and `specified_height` are known, but it is useful to call this
             * function in GtkWidget:measure implementations to compute the
             * other dimension when only one dimension is given.
             * @param specified_width the width @paintable could be drawn into or   0.0 if unknown
             * @param specified_height the height @paintable could be drawn into or   0.0 if unknown
             * @param default_width the width @paintable would be drawn into if   no other constraints were given
             * @param default_height the height @paintable would be drawn into if   no other constraints were given
             */
            compute_concrete_size(
                specified_width: number,
                specified_height: number,
                default_width: number,
                default_height: number,
            ): [number, number];
            /**
             * Gets an immutable paintable for the current contents displayed by `paintable`.
             *
             * This is useful when you want to retain the current state of an animation,
             * for example to take a screenshot of a running animation.
             *
             * If the `paintable` is already immutable, it will return itself.
             * @returns An immutable paintable for the current   contents of @paintable
             */
            get_current_image(): Gdk.Paintable;
            /**
             * Get flags for the paintable.
             *
             * This is oftentimes useful for optimizations.
             *
             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
             * @returns The `GdkPaintableFlags` for this paintable
             */
            get_flags(): Gdk.PaintableFlags;
            /**
             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
             *
             * The aspect ratio is the width divided by the height, so a value of 0.5
             * means that the `paintable` prefers to be displayed twice as high as it
             * is wide. Consumers of this interface can use this to preserve aspect
             * ratio when displaying the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * Usually when a `paintable` returns nonzero values from
             * [method`Gdk`.Paintable.get_intrinsic_width] and
             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
             * should conform to those values, though that is not required.
             *
             * If the `paintable` does not have a preferred aspect ratio,
             * it returns 0. Negative values are never returned.
             * @returns the intrinsic aspect ratio of @paintable or 0 if none.
             */
            get_intrinsic_aspect_ratio(): number;
            /**
             * Gets the preferred height the `paintable` would like to be displayed at.
             *
             * Consumers of this interface can use this to reserve enough space to draw
             * the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * If the `paintable` does not have a preferred height, it returns 0.
             * Negative values are never returned.
             * @returns the intrinsic height of @paintable or 0 if none.
             */
            get_intrinsic_height(): number;
            /**
             * Gets the preferred width the `paintable` would like to be displayed at.
             *
             * Consumers of this interface can use this to reserve enough space to draw
             * the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * If the `paintable` does not have a preferred width, it returns 0.
             * Negative values are never returned.
             * @returns the intrinsic width of @paintable or 0 if none.
             */
            get_intrinsic_width(): number;
            /**
             * Called by implementations of `GdkPaintable` to invalidate their contents.
             *
             * Unless the contents are invalidated, implementations must guarantee that
             * multiple calls of [method`Gdk`.Paintable.snapshot] produce the same output.
             *
             * This function will emit the [signal`Gdk`.Paintable::invalidate-contents]
             * signal.
             *
             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_CONTENTS flag,
             * it must not call this function.
             */
            invalidate_contents(): void;
            /**
             * Called by implementations of `GdkPaintable` to invalidate their size.
             *
             * As long as the size is not invalidated, `paintable` must return the same
             * values for its intrinsic width, height and aspect ratio.
             *
             * This function will emit the [signal`Gdk`.Paintable::invalidate-size]
             * signal.
             *
             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_SIZE flag,
             * it must not call this function.
             */
            invalidate_size(): void;
            /**
             * Snapshots the given paintable with the given `width` and `height`.
             *
             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
             * If `width` and `height` are not larger than zero, this function will
             * do nothing.
             * @param snapshot a `GdkSnapshot` to snapshot to
             * @param width width to snapshot in
             * @param height height to snapshot in
             */
            snapshot(snapshot: Gdk.Snapshot, width: number, height: number): void;
            /**
             * Gets an immutable paintable for the current contents displayed by `paintable`.
             *
             * This is useful when you want to retain the current state of an animation,
             * for example to take a screenshot of a running animation.
             *
             * If the `paintable` is already immutable, it will return itself.
             */
            vfunc_get_current_image(): Gdk.Paintable;
            /**
             * Get flags for the paintable.
             *
             * This is oftentimes useful for optimizations.
             *
             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
             */
            vfunc_get_flags(): Gdk.PaintableFlags;
            /**
             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
             *
             * The aspect ratio is the width divided by the height, so a value of 0.5
             * means that the `paintable` prefers to be displayed twice as high as it
             * is wide. Consumers of this interface can use this to preserve aspect
             * ratio when displaying the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * Usually when a `paintable` returns nonzero values from
             * [method`Gdk`.Paintable.get_intrinsic_width] and
             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
             * should conform to those values, though that is not required.
             *
             * If the `paintable` does not have a preferred aspect ratio,
             * it returns 0. Negative values are never returned.
             */
            vfunc_get_intrinsic_aspect_ratio(): number;
            /**
             * Gets the preferred height the `paintable` would like to be displayed at.
             *
             * Consumers of this interface can use this to reserve enough space to draw
             * the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * If the `paintable` does not have a preferred height, it returns 0.
             * Negative values are never returned.
             */
            vfunc_get_intrinsic_height(): number;
            /**
             * Gets the preferred width the `paintable` would like to be displayed at.
             *
             * Consumers of this interface can use this to reserve enough space to draw
             * the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * If the `paintable` does not have a preferred width, it returns 0.
             * Negative values are never returned.
             */
            vfunc_get_intrinsic_width(): number;
            /**
             * Snapshots the given paintable with the given `width` and `height`.
             *
             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
             * If `width` and `height` are not larger than zero, this function will
             * do nothing.
             * @param snapshot a `GdkSnapshot` to snapshot to
             * @param width width to snapshot in
             * @param height height to snapshot in
             */
            vfunc_snapshot(snapshot: Gdk.Snapshot, width: number, height: number): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace MenuButton {
            // Signal callback interfaces

            interface Activate {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                active: boolean;
                always_show_arrow: boolean;
                alwaysShowArrow: boolean;
                can_shrink: boolean;
                canShrink: boolean;
                child: Widget;
                direction: ArrowType;
                has_frame: boolean;
                hasFrame: boolean;
                icon_name: string;
                iconName: string;
                label: string;
                menu_model: Gio.MenuModel;
                menuModel: Gio.MenuModel;
                popover: Popover;
                primary: boolean;
                use_underline: boolean;
                useUnderline: boolean;
            }
        }

        /**
         * The `GtkMenuButton` widget is used to display a popup when clicked.
         *
         * ![An example GtkMenuButton](menu-button.png)
         *
         * This popup can be provided either as a `GtkPopover` or as an abstract
         * `GMenuModel`.
         *
         * The `GtkMenuButton` widget can show either an icon (set with the
         * [property`Gtk`.MenuButton:icon-name] property) or a label (set with the
         * [property`Gtk`.MenuButton:label] property). If neither is explicitly set,
         * a [class`Gtk`.Image] is automatically created, using an arrow image oriented
         * according to [property`Gtk`.MenuButton:direction] or the generic
         * “open-menu-symbolic” icon if the direction is not set.
         *
         * The positioning of the popup is determined by the
         * [property`Gtk`.MenuButton:direction] property of the menu button.
         *
         * For menus, the [property`Gtk`.Widget:halign] and [property`Gtk`.Widget:valign]
         * properties of the menu are also taken into account. For example, when the
         * direction is %GTK_ARROW_DOWN and the horizontal alignment is %GTK_ALIGN_START,
         * the menu will be positioned below the button, with the starting edge
         * (depending on the text direction) of the menu aligned with the starting
         * edge of the button. If there is not enough space below the button, the
         * menu is popped up above the button instead. If the alignment would move
         * part of the menu offscreen, it is “pushed in”.
         *
         * |           | start                | center                | end                |
         * | -         | ---                  | ---                   | ---                |
         * | **down**  | ![](down-start.png)  | ![](down-center.png)  | ![](down-end.png)  |
         * | **up**    | ![](up-start.png)    | ![](up-center.png)    | ![](up-end.png)    |
         * | **left**  | ![](left-start.png)  | ![](left-center.png)  | ![](left-end.png)  |
         * | **right** | ![](right-start.png) | ![](right-center.png) | ![](right-end.png) |
         *
         * # CSS nodes
         *
         * ```
         * menubutton
         * ╰── button.toggle
         *     ╰── <content>
         *          ╰── [arrow]
         * ```
         *
         * `GtkMenuButton` has a single CSS node with name `menubutton`
         * which contains a `button` node with a `.toggle` style class.
         *
         * If the button contains an icon, it will have the `.image-button` style class,
         * if it contains text, it will have `.text-button` style class. If an arrow is
         * visible in addition to an icon, text or a custom child, it will also have
         * `.arrow-button` style class.
         *
         * Inside the toggle button content, there is an `arrow` node for
         * the indicator, which will carry one of the `.none`, `.up`, `.down`,
         * `.left` or `.right` style classes to indicate the direction that
         * the menu will appear in. The CSS is expected to provide a suitable
         * image for each of these cases using the `-gtk-icon-source` property.
         *
         * Optionally, the `menubutton` node can carry the `.circular` style class
         * to request a round appearance.
         *
         * # Accessibility
         *
         * `GtkMenuButton` uses the %GTK_ACCESSIBLE_ROLE_BUTTON role.
         */
        class MenuButton extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<MenuButton>;

            // Properties

            /**
             * Whether the menu button is active.
             */
            get active(): boolean;
            set active(val: boolean);
            /**
             * Whether to show a dropdown arrow even when using an icon or a custom child.
             */
            get always_show_arrow(): boolean;
            set always_show_arrow(val: boolean);
            /**
             * Whether to show a dropdown arrow even when using an icon or a custom child.
             */
            get alwaysShowArrow(): boolean;
            set alwaysShowArrow(val: boolean);
            /**
             * Whether the size of the button can be made smaller than the natural
             * size of its contents.
             */
            get can_shrink(): boolean;
            set can_shrink(val: boolean);
            /**
             * Whether the size of the button can be made smaller than the natural
             * size of its contents.
             */
            get canShrink(): boolean;
            set canShrink(val: boolean);
            /**
             * The child widget.
             */
            get child(): Widget;
            set child(val: Widget);
            /**
             * The `GtkArrowType` representing the direction in which the
             * menu or popover will be popped out.
             */
            get direction(): ArrowType;
            set direction(val: ArrowType);
            /**
             * Whether the button has a frame.
             */
            get has_frame(): boolean;
            set has_frame(val: boolean);
            /**
             * Whether the button has a frame.
             */
            get hasFrame(): boolean;
            set hasFrame(val: boolean);
            /**
             * The name of the icon used to automatically populate the button.
             */
            get icon_name(): string;
            set icon_name(val: string);
            /**
             * The name of the icon used to automatically populate the button.
             */
            get iconName(): string;
            set iconName(val: string);
            /**
             * The label for the button.
             */
            get label(): string;
            set label(val: string);
            /**
             * The `GMenuModel` from which the popup will be created.
             *
             * See [method`Gtk`.MenuButton.set_menu_model] for the interaction
             * with the [property`Gtk`.MenuButton:popover] property.
             */
            get menu_model(): Gio.MenuModel;
            set menu_model(val: Gio.MenuModel);
            /**
             * The `GMenuModel` from which the popup will be created.
             *
             * See [method`Gtk`.MenuButton.set_menu_model] for the interaction
             * with the [property`Gtk`.MenuButton:popover] property.
             */
            get menuModel(): Gio.MenuModel;
            set menuModel(val: Gio.MenuModel);
            /**
             * The `GtkPopover` that will be popped up when the button is clicked.
             */
            get popover(): Popover;
            set popover(val: Popover);
            /**
             * Whether the menu button acts as a primary menu.
             *
             * Primary menus can be opened using the <kbd>F10</kbd> key
             */
            get primary(): boolean;
            set primary(val: boolean);
            /**
             * If set an underscore in the text indicates a mnemonic.
             */
            get use_underline(): boolean;
            set use_underline(val: boolean);
            /**
             * If set an underscore in the text indicates a mnemonic.
             */
            get useUnderline(): boolean;
            set useUnderline(val: boolean);

            // Constructors

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

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

            static ['new'](): MenuButton;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate', callback: (_source: this) => void): number;
            connect_after(signal: 'activate', callback: (_source: this) => void): number;
            emit(signal: 'activate'): void;

            // Methods

            /**
             * Returns whether the menu button is active.
             * @returns TRUE if the button is active
             */
            get_active(): boolean;
            /**
             * Gets whether to show a dropdown arrow even when using an icon or a custom
             * child.
             * @returns whether to show a dropdown arrow even when using an icon or a custom child.
             */
            get_always_show_arrow(): boolean;
            /**
             * Retrieves whether the button can be smaller than the natural
             * size of its contents.
             * @returns true if the button can shrink, and false otherwise
             */
            get_can_shrink(): boolean;
            /**
             * Gets the child widget of `menu_button`.
             * @returns the child widget of @menu_button
             */
            get_child(): Widget | null;
            /**
             * Returns the direction the popup will be pointing at when popped up.
             * @returns a `GtkArrowType` value
             */
            get_direction(): ArrowType;
            // Conflicted with Gtk.Widget.get_direction
            get_direction(...args: never[]): any;
            /**
             * Returns whether the button has a frame.
             * @returns %TRUE if the button has a frame
             */
            get_has_frame(): boolean;
            /**
             * Gets the name of the icon shown in the button.
             * @returns the name of the icon shown in the button
             */
            get_icon_name(): string | null;
            /**
             * Gets the label shown in the button
             * @returns the label shown in the button
             */
            get_label(): string | null;
            /**
             * Returns the `GMenuModel` used to generate the popup.
             * @returns a `GMenuModel`
             */
            get_menu_model(): Gio.MenuModel | null;
            /**
             * Returns the `GtkPopover` that pops out of the button.
             *
             * If the button is not using a `GtkPopover`, this function
             * returns %NULL.
             * @returns a `GtkPopover` or %NULL
             */
            get_popover(): Popover | null;
            /**
             * Returns whether the menu button acts as a primary menu.
             * @returns %TRUE if the button is a primary menu
             */
            get_primary(): boolean;
            /**
             * Returns whether an embedded underline in the text indicates a
             * mnemonic.
             * @returns %TRUE whether an embedded underline in the text indicates   the mnemonic accelerator keys.
             */
            get_use_underline(): boolean;
            /**
             * Dismiss the menu.
             */
            popdown(): void;
            /**
             * Pop up the menu.
             */
            popup(): void;
            /**
             * Sets whether the menu button is active.
             * @param active whether the menu button is active
             */
            set_active(active: boolean): void;
            /**
             * Sets whether to show a dropdown arrow even when using an icon or a custom
             * child.
             * @param always_show_arrow whether to show a dropdown arrow even when using an icon or a custom child
             */
            set_always_show_arrow(always_show_arrow: boolean): void;
            /**
             * Sets whether the button size can be smaller than the natural size of
             * its contents.
             *
             * For text buttons, setting `can_shrink` to true will ellipsize the label.
             *
             * For icon buttons, this function has no effect.
             * @param can_shrink whether the button can shrink
             */
            set_can_shrink(can_shrink: boolean): void;
            /**
             * Sets the child widget of `menu_button`.
             *
             * Setting a child resets [property`Gtk`.MenuButton:label] and
             * [property`Gtk`.MenuButton:icon-name].
             *
             * If [property`Gtk`.MenuButton:always-show-arrow] is set to `TRUE` and
             * [property`Gtk`.MenuButton:direction] is not `GTK_ARROW_NONE`, a dropdown arrow
             * will be shown next to the child.
             * @param child the child widget
             */
            set_child(child?: Widget | null): void;
            /**
             * Sets `func` to be called when a popup is about to be shown.
             *
             * `func` should use one of
             *
             *  - [method`Gtk`.MenuButton.set_popover]
             *  - [method`Gtk`.MenuButton.set_menu_model]
             *
             * to set a popup for `menu_button`.
             * If `func` is non-%NULL, `menu_button` will always be sensitive.
             *
             * Using this function will not reset the menu widget attached to
             * `menu_button`. Instead, this can be done manually in `func`.
             * @param func function   to call when a popup is about to be shown, but none has been provided via other means,   or %NULL to reset to default behavior
             * @param destroy_notify destroy notify for @user_data
             */
            set_create_popup_func(
                func?: MenuButtonCreatePopupFunc | null,
                destroy_notify?: GLib.DestroyNotify | null,
            ): void;
            /**
             * Sets the direction in which the popup will be popped up.
             *
             * If the button is automatically populated with an arrow icon,
             * its direction will be changed to match.
             *
             * If the does not fit in the available space in the given direction,
             * GTK will its best to keep it inside the screen and fully visible.
             *
             * If you pass %GTK_ARROW_NONE for a `direction,` the popup will behave
             * as if you passed %GTK_ARROW_DOWN (although you won’t see any arrows).
             * @param direction a `GtkArrowType`
             */
            set_direction(direction: ArrowType | null): void;
            // Conflicted with Gtk.Widget.set_direction
            set_direction(...args: never[]): any;
            /**
             * Sets the style of the button.
             * @param has_frame whether the button should have a visible frame
             */
            set_has_frame(has_frame: boolean): void;
            /**
             * Sets the name of an icon to show inside the menu button.
             *
             * Setting icon name resets [property`Gtk`.MenuButton:label] and
             * [property`Gtk`.MenuButton:child].
             *
             * If [property`Gtk`.MenuButton:always-show-arrow] is set to `TRUE` and
             * [property`Gtk`.MenuButton:direction] is not `GTK_ARROW_NONE`, a dropdown arrow
             * will be shown next to the icon.
             * @param icon_name the icon name
             */
            set_icon_name(icon_name: string): void;
            /**
             * Sets the label to show inside the menu button.
             *
             * Setting a label resets [property`Gtk`.MenuButton:icon-name] and
             * [property`Gtk`.MenuButton:child].
             *
             * If [property`Gtk`.MenuButton:direction] is not `GTK_ARROW_NONE`, a dropdown
             * arrow will be shown next to the label.
             * @param label the label
             */
            set_label(label: string): void;
            /**
             * Sets the `GMenuModel` from which the popup will be constructed.
             *
             * If `menu_model` is %NULL, the button is disabled.
             *
             * A [class`Gtk`.Popover] will be created from the menu model with
             * [ctor`Gtk`.PopoverMenu.new_from_model]. Actions will be connected
             * as documented for this function.
             *
             * If [property`Gtk`.MenuButton:popover] is already set, it will be
             * dissociated from the `menu_button,` and the property is set to %NULL.
             * @param menu_model a `GMenuModel`, or %NULL to unset and disable the   button
             */
            set_menu_model(menu_model?: Gio.MenuModel | null): void;
            /**
             * Sets the `GtkPopover` that will be popped up when the `menu_button` is clicked.
             *
             * If `popover` is %NULL, the button is disabled.
             *
             * If [property`Gtk`.MenuButton:menu-model] is set, the menu model is dissociated
             * from the `menu_button,` and the property is set to %NULL.
             * @param popover a `GtkPopover`, or %NULL to unset and disable the button
             */
            set_popover(popover?: Widget | null): void;
            /**
             * Sets whether menu button acts as a primary menu.
             *
             * Primary menus can be opened with the <kbd>F10</kbd> key.
             * @param primary whether the menubutton should act as a primary menu
             */
            set_primary(primary: boolean): void;
            /**
             * If true, an underline in the text indicates a mnemonic.
             * @param use_underline %TRUE if underlines in the text indicate mnemonics
             */
            set_use_underline(use_underline: boolean): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace MessageDialog {
            // Constructor properties interface

            interface ConstructorProps
                extends Dialog.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Native.ConstructorProps,
                    Root.ConstructorProps,
                    ShortcutManager.ConstructorProps {
                buttons: ButtonsType;
                message_area: Widget;
                messageArea: Widget;
                message_type: MessageType;
                messageType: MessageType;
                secondary_text: string;
                secondaryText: string;
                secondary_use_markup: boolean;
                secondaryUseMarkup: boolean;
                text: string;
                use_markup: boolean;
                useMarkup: boolean;
            }
        }

        /**
         * `GtkMessageDialog` presents a dialog with some message text.
         *
         * ![An example GtkMessageDialog](messagedialog.png)
         *
         * It’s simply a convenience widget; you could construct the equivalent of
         * `GtkMessageDialog` from `GtkDialog` without too much effort, but
         * `GtkMessageDialog` saves typing.
         *
         * The easiest way to do a modal message dialog is to use the %GTK_DIALOG_MODAL
         * flag, which will call [method`Gtk`.Window.set_modal] internally. The dialog will
         * prevent interaction with the parent window until it's hidden or destroyed.
         * You can use the [signal`Gtk`.Dialog::response] signal to know when the user
         * dismissed the dialog.
         *
         * An example for using a modal dialog:
         * ```c
         * GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL;
         * dialog = gtk_message_dialog_new (parent_window,
         *                                  flags,
         *                                  GTK_MESSAGE_ERROR,
         *                                  GTK_BUTTONS_CLOSE,
         *                                  "Error reading “%s”: %s",
         *                                  filename,
         *                                  g_strerror (errno));
         * // Destroy the dialog when the user responds to it
         * // (e.g. clicks a button)
         *
         * g_signal_connect (dialog, "response",
         *                   G_CALLBACK (gtk_window_destroy),
         *                   NULL);
         * ```
         *
         * You might do a non-modal `GtkMessageDialog` simply by omitting the
         * %GTK_DIALOG_MODAL flag:
         *
         * ```c
         * GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
         * dialog = gtk_message_dialog_new (parent_window,
         *                                  flags,
         *                                  GTK_MESSAGE_ERROR,
         *                                  GTK_BUTTONS_CLOSE,
         *                                  "Error reading “%s”: %s",
         *                                  filename,
         *                                  g_strerror (errno));
         *
         * // Destroy the dialog when the user responds to it
         * // (e.g. clicks a button)
         * g_signal_connect (dialog, "response",
         *                   G_CALLBACK (gtk_window_destroy),
         *                   NULL);
         * ```
         *
         * # GtkMessageDialog as GtkBuildable
         *
         * The `GtkMessageDialog` implementation of the `GtkBuildable` interface exposes
         * the message area as an internal child with the name “message_area”.
         */
        class MessageDialog
            extends Dialog
            implements Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager
        {
            static $gtype: GObject.GType<MessageDialog>;

            // Properties

            /**
             * Set of buttons to display on the dialog.
             */
            set buttons(val: ButtonsType);
            /**
             * The `GtkBox` that corresponds to the message area of this dialog.
             *
             * See [method`Gtk`.MessageDialog.get_message_area] for a detailed
             * description of this area.
             */
            get message_area(): Widget;
            /**
             * The `GtkBox` that corresponds to the message area of this dialog.
             *
             * See [method`Gtk`.MessageDialog.get_message_area] for a detailed
             * description of this area.
             */
            get messageArea(): Widget;
            /**
             * The type of the message.
             */
            get message_type(): MessageType;
            set message_type(val: MessageType);
            /**
             * The type of the message.
             */
            get messageType(): MessageType;
            set messageType(val: MessageType);
            /**
             * The secondary text of the message dialog.
             */
            get secondary_text(): string;
            set secondary_text(val: string);
            /**
             * The secondary text of the message dialog.
             */
            get secondaryText(): string;
            set secondaryText(val: string);
            /**
             * %TRUE if the secondary text of the dialog includes Pango markup.
             *
             * See [func`Pango`.parse_markup].
             */
            get secondary_use_markup(): boolean;
            set secondary_use_markup(val: boolean);
            /**
             * %TRUE if the secondary text of the dialog includes Pango markup.
             *
             * See [func`Pango`.parse_markup].
             */
            get secondaryUseMarkup(): boolean;
            set secondaryUseMarkup(val: boolean);
            /**
             * The primary text of the message dialog.
             *
             * If the dialog has a secondary text, this will appear as the title.
             */
            get text(): string;
            set text(val: string);
            /**
             * %TRUE if the primary text of the dialog includes Pango markup.
             *
             * See [func`Pango`.parse_markup].
             */
            get use_markup(): boolean;
            set use_markup(val: boolean);
            /**
             * %TRUE if the primary text of the dialog includes Pango markup.
             *
             * See [func`Pango`.parse_markup].
             */
            get useMarkup(): boolean;
            set useMarkup(val: boolean);

            // Constructors

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

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

            // Methods

            /**
             * Returns the message area of the dialog.
             *
             * This is the box where the dialog’s primary and secondary labels
             * are packed. You can add your own extra content to that box and it
             * will appear below those labels. See [method`Gtk`.Dialog.get_content_area]
             * for the corresponding function in the parent [class`Gtk`.Dialog].
             * @returns A `GtkBox` corresponding to the   “message area” in the @message_dialog
             */
            get_message_area(): Widget;
            /**
             * Sets the text of the message dialog.
             * @param str string with Pango markup
             */
            set_markup(str: string): void;

            // Inherited properties
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace MnemonicAction {
            // Constructor properties interface

            interface ConstructorProps extends ShortcutAction.ConstructorProps {}
        }

        /**
         * A `GtkShortcutAction` that calls gtk_widget_mnemonic_activate().
         */
        class MnemonicAction extends ShortcutAction {
            static $gtype: GObject.GType<MnemonicAction>;

            // Constructors

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

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

            // Static methods

            /**
             * Gets the mnemonic action.
             *
             * This is an action that calls gtk_widget_mnemonic_activate()
             * on the given widget upon activation.
             */
            static get(): MnemonicAction;
        }

        namespace MnemonicTrigger {
            // Constructor properties interface

            interface ConstructorProps extends ShortcutTrigger.ConstructorProps {
                keyval: number;
            }
        }

        /**
         * A `GtkShortcutTrigger` that triggers when a specific mnemonic is pressed.
         *
         * Mnemonics require a *mnemonic modifier* (typically <kbd>Alt</kbd>) to be
         * pressed together with the mnemonic key.
         */
        class MnemonicTrigger extends ShortcutTrigger {
            static $gtype: GObject.GType<MnemonicTrigger>;

            // Properties

            /**
             * The key value for the trigger.
             */
            get keyval(): number;

            // Constructors

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

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

            static ['new'](keyval: number): MnemonicTrigger;

            // Methods

            /**
             * Gets the keyval that must be pressed to succeed triggering `self`.
             * @returns the keyval
             */
            get_keyval(): number;
        }

        namespace MountOperation {
            // Constructor properties interface

            interface ConstructorProps extends Gio.MountOperation.ConstructorProps {
                display: Gdk.Display;
                is_showing: boolean;
                isShowing: boolean;
                parent: Window;
            }
        }

        /**
         * `GtkMountOperation` is an implementation of `GMountOperation`.
         *
         * The functions and objects described here make working with GTK and
         * GIO more convenient.
         *
         * `GtkMountOperation` is needed when mounting volumes:
         * It is an implementation of `GMountOperation` that can be used with
         * GIO functions for mounting volumes such as
         * g_file_mount_enclosing_volume(), g_file_mount_mountable(),
         * g_volume_mount(), g_mount_unmount_with_operation() and others.
         *
         * When necessary, `GtkMountOperation` shows dialogs to let the user
         * enter passwords, ask questions or show processes blocking unmount.
         */
        class MountOperation extends Gio.MountOperation {
            static $gtype: GObject.GType<MountOperation>;

            // Properties

            /**
             * The display where dialogs will be shown.
             */
            get display(): Gdk.Display;
            set display(val: Gdk.Display);
            /**
             * Whether a dialog is currently shown.
             */
            get is_showing(): boolean;
            /**
             * Whether a dialog is currently shown.
             */
            get isShowing(): boolean;
            /**
             * The parent window.
             */
            get parent(): Window;
            set parent(val: Window);

            // Constructors

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

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

            static ['new'](parent?: Window | null): MountOperation;
            // Conflicted with Gio.MountOperation.new

            static ['new'](...args: never[]): any;

            // Methods

            /**
             * Gets the display on which windows of the `GtkMountOperation`
             * will be shown.
             * @returns the display on which windows of @op are shown
             */
            get_display(): Gdk.Display;
            /**
             * Gets the transient parent used by the `GtkMountOperation`.
             * @returns the transient parent for windows shown by @op
             */
            get_parent(): Window | null;
            /**
             * Sets the display to show windows of the `GtkMountOperation` on.
             * @param display a `GdkDisplay`
             */
            set_display(display: Gdk.Display): void;
            /**
             * Sets the transient parent for windows shown by the
             * `GtkMountOperation`.
             * @param parent transient parent of the window
             */
            set_parent(parent?: Window | null): void;
        }

        namespace MultiFilter {
            // Constructor properties interface

            interface ConstructorProps<A extends GObject.Object = GObject.Object>
                extends Filter.ConstructorProps,
                    Gio.ListModel.ConstructorProps,
                    Buildable.ConstructorProps {
                item_type: GObject.GType;
                itemType: GObject.GType;
                n_items: number;
                nItems: number;
            }
        }

        /**
         * `GtkMultiFilter` is the base class for filters that combine multiple filters.
         */
        abstract class MultiFilter<A extends GObject.Object = GObject.Object>
            extends Filter
            implements Gio.ListModel<A>, Buildable
        {
            static $gtype: GObject.GType<MultiFilter>;

            // Properties

            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get item_type(): GObject.GType;
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get itemType(): GObject.GType;
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get n_items(): number;
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get nItems(): number;

            // Constructors

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

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

            // Methods

            /**
             * Adds a `filter` to `self` to use for matching.
             * @param filter A new filter to use
             */
            append(filter: Filter): void;
            /**
             * Removes the filter at the given `position` from the list of filters used
             * by `self`.
             *
             * If `position` is larger than the number of filters, nothing happens and
             * the function returns.
             * @param position position of filter to remove
             */
            remove(position: number): void;

            // Inherited methods
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             * @returns the #GType of the items contained in @list.
             */
            get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             * @returns the number of items in @list.
             */
            get_n_items(): number;
            /**
             * Get the item at `position`.
             *
             * If `position` is greater than the number of items in `list,` %NULL is
             * returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.
             *
             * This function is meant to be used by language bindings in place
             * of g_list_model_get_item().
             *
             * See also: g_list_model_get_n_items()
             * @param position the position of the item to fetch
             * @returns the object at @position.
             */
            get_item(position: number): A | null;
            /**
             * Emits the #GListModel::items-changed signal on `list`.
             *
             * This function should only be called by classes implementing
             * #GListModel. It has to be called after the internal representation
             * of `list` has been updated, because handlers connected to this signal
             * might query the new state of the list.
             *
             * Implementations must only make changes to the model (as visible to
             * its consumer) in places that will not cause problems for that
             * consumer.  For models that are driven directly by a write API (such
             * as #GListStore), changes can be reported in response to uses of that
             * API.  For models that represent remote data, changes should only be
             * made from a fresh mainloop dispatch.  It is particularly not
             * permitted to make changes in response to a call to the #GListModel
             * consumer API.
             *
             * Stated another way: in general, it is assumed that code making a
             * series of accesses to the model via the API, without returning to the
             * mainloop, and without calling other code, will continue to view the
             * same contents of the model.
             * @param position the position at which @list changed
             * @param removed the number of items removed
             * @param added the number of items added
             */
            items_changed(position: number, removed: number, added: number): void;
            /**
             * Get the item at `position`. If `position` is greater than the number of
             * items in `list,` %NULL is returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.  See g_list_model_get_n_items().
             *
             * The same #GObject instance may not appear more than once in a #GListModel.
             * @param position the position of the item to fetch
             */
            vfunc_get_item(position: number): A | null;
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             */
            vfunc_get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             */
            vfunc_get_n_items(): number;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace MultiSelection {
            // Constructor properties interface

            interface ConstructorProps<A extends GObject.Object = GObject.Object>
                extends GObject.Object.ConstructorProps,
                    Gio.ListModel.ConstructorProps,
                    SectionModel.ConstructorProps,
                    SelectionModel.ConstructorProps {
                item_type: GObject.GType;
                itemType: GObject.GType;
                model: Gio.ListModel;
                n_items: number;
                nItems: number;
            }
        }

        /**
         * `GtkMultiSelection` is a `GtkSelectionModel` that allows selecting multiple
         * elements.
         */
        class MultiSelection<A extends GObject.Object = GObject.Object>
            extends GObject.Object
            implements Gio.ListModel<A>, SectionModel, SelectionModel
        {
            static $gtype: GObject.GType<MultiSelection>;

            // Properties

            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get item_type(): GObject.GType;
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get itemType(): GObject.GType;
            /**
             * The list managed by this selection.
             */
            get model(): Gio.ListModel;
            set model(val: Gio.ListModel);
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get n_items(): number;
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get nItems(): number;

            // Constructors

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

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

            static ['new'](model?: Gio.ListModel | null): MultiSelection;

            // Methods

            /**
             * Returns the underlying model of `self`.
             * @returns the underlying model
             */
            get_model(): Gio.ListModel | null;
            /**
             * Sets the model that `self` should wrap.
             *
             * If `model` is %NULL, `self` will be empty.
             * @param model A `GListModel` to wrap
             */
            set_model(model?: Gio.ListModel | null): void;

            // Inherited methods
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             * @returns the #GType of the items contained in @list.
             */
            get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             * @returns the number of items in @list.
             */
            get_n_items(): number;
            /**
             * Get the item at `position`.
             *
             * If `position` is greater than the number of items in `list,` %NULL is
             * returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.
             *
             * This function is meant to be used by language bindings in place
             * of g_list_model_get_item().
             *
             * See also: g_list_model_get_n_items()
             * @param position the position of the item to fetch
             * @returns the object at @position.
             */
            get_item(position: number): A | null;
            /**
             * Emits the #GListModel::items-changed signal on `list`.
             *
             * This function should only be called by classes implementing
             * #GListModel. It has to be called after the internal representation
             * of `list` has been updated, because handlers connected to this signal
             * might query the new state of the list.
             *
             * Implementations must only make changes to the model (as visible to
             * its consumer) in places that will not cause problems for that
             * consumer.  For models that are driven directly by a write API (such
             * as #GListStore), changes can be reported in response to uses of that
             * API.  For models that represent remote data, changes should only be
             * made from a fresh mainloop dispatch.  It is particularly not
             * permitted to make changes in response to a call to the #GListModel
             * consumer API.
             *
             * Stated another way: in general, it is assumed that code making a
             * series of accesses to the model via the API, without returning to the
             * mainloop, and without calling other code, will continue to view the
             * same contents of the model.
             * @param position the position at which @list changed
             * @param removed the number of items removed
             * @param added the number of items added
             */
            items_changed(position: number, removed: number, added: number): void;
            /**
             * Get the item at `position`. If `position` is greater than the number of
             * items in `list,` %NULL is returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.  See g_list_model_get_n_items().
             *
             * The same #GObject instance may not appear more than once in a #GListModel.
             * @param position the position of the item to fetch
             */
            vfunc_get_item(position: number): A | null;
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             */
            vfunc_get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             */
            vfunc_get_n_items(): number;
            /**
             * Query the section that covers the given position. The number of
             * items in the section can be computed by `out_end - out_start`.
             *
             * If the position is larger than the number of items, a single
             * range from n_items to G_MAXUINT will be returned.
             * @param position the position of the item to query
             */
            get_section(position: number): [number, number];
            /**
             * This function emits the [signal`Gtk`.SectionModel::sections-changed]
             * signal to notify about changes to sections.
             *
             * It must cover all positions that used to be a section start or that
             * are now a section start. It does not have to cover all positions for
             * which the section has changed.
             *
             * The [signal`Gio`.ListModel::items-changed] implies the effect of the
             * [signal`Gtk`.SectionModel::sections-changed] signal for all the items
             * it covers.
             *
             * It is recommended that when changes to the items cause section changes
             * in a larger range, that the larger range is included in the emission
             * of the [signal`Gio`.ListModel::items-changed] instead of emitting
             * two signals.
             * @param position the first changed item
             * @param n_items the number of changed items
             */
            sections_changed(position: number, n_items: number): void;
            /**
             * Query the section that covers the given position. The number of
             * items in the section can be computed by `out_end - out_start`.
             *
             * If the position is larger than the number of items, a single
             * range from n_items to G_MAXUINT will be returned.
             * @param position the position of the item to query
             */
            vfunc_get_section(position: number): [number, number];
            /**
             * Gets the set containing all currently selected items in the model.
             *
             * This function may be slow, so if you are only interested in single item,
             * consider using [method`Gtk`.SelectionModel.is_selected] or if you are only
             * interested in a few, consider [method`Gtk`.SelectionModel.get_selection_in_range].
             * @returns a `GtkBitset` containing all the values currently   selected in @model. If no items are selected, the bitset is empty.   The bitset must not be modified.
             */
            get_selection(): Bitset;
            /**
             * Gets the set of selected items in a range.
             *
             * This function is an optimization for
             * [method`Gtk`.SelectionModel.get_selection] when you are only
             * interested in part of the model's selected state. A common use
             * case is in response to the [signal`Gtk`.SelectionModel::selection-changed]
             * signal.
             * @param position start of the queried range
             * @param n_items number of items in the queried range
             * @returns A `GtkBitset` that matches the selection state   for the given range with all other values being undefined.   The bitset must not be modified.
             */
            get_selection_in_range(position: number, n_items: number): Bitset;
            /**
             * Checks if the given item is selected.
             * @param position the position of the item to query
             * @returns %TRUE if the item is selected
             */
            is_selected(position: number): boolean;
            /**
             * Requests to select all items in the model.
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items are now selected.
             */
            select_all(): boolean;
            /**
             * Requests to select an item in the model.
             * @param position the position of the item to select
             * @param unselect_rest whether previously selected items should be unselected
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the item was selected.
             */
            select_item(position: number, unselect_rest: boolean): boolean;
            /**
             * Requests to select a range of items in the model.
             * @param position the first item to select
             * @param n_items the number of items to select
             * @param unselect_rest whether previously selected items should be unselected
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the range was selected.
             */
            select_range(position: number, n_items: number, unselect_rest: boolean): boolean;
            /**
             * Helper function for implementations of `GtkSelectionModel`.
             *
             * Call this when the selection changes to emit the
             * [signal`Gtk`.SelectionModel::selection-changed] signal.
             * @param position the first changed item
             * @param n_items the number of changed items
             */
            selection_changed(position: number, n_items: number): void;
            /**
             * Make selection changes.
             *
             * This is the most advanced selection updating method that allows
             * the most fine-grained control over selection changes. If you can,
             * you should try the simpler versions, as implementations are more
             * likely to implement support for those.
             *
             * Requests that the selection state of all positions set in `mask`
             * be updated to the respective value in the `selected` bitmask.
             *
             * In pseudocode, it would look something like this:
             *
             * ```c
             * for (i = 0; i < n_items; i++)
             *   {
             *     // don't change values not in the mask
             *     if (!gtk_bitset_contains (mask, i))
             *       continue;
             *
             *     if (gtk_bitset_contains (selected, i))
             *       select_item (i);
             *     else
             *       unselect_item (i);
             *   }
             *
             * gtk_selection_model_selection_changed (model,
             *                                        first_changed_item,
             *                                        n_changed_items);
             * ```
             *
             * `mask` and `selected` must not be modified. They may refer to the
             * same bitset, which would mean that every item in the set should
             * be selected.
             * @param selected bitmask specifying if items should be selected or unselected
             * @param mask bitmask specifying which items should be updated
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items were updated according   to the inputs.
             */
            set_selection(selected: Bitset, mask: Bitset): boolean;
            /**
             * Requests to unselect all items in the model.
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items are now unselected.
             */
            unselect_all(): boolean;
            /**
             * Requests to unselect an item in the model.
             * @param position the position of the item to unselect
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the item was unselected.
             */
            unselect_item(position: number): boolean;
            /**
             * Requests to unselect a range of items in the model.
             * @param position the first item to unselect
             * @param n_items the number of items to unselect
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the range was unselected.
             */
            unselect_range(position: number, n_items: number): boolean;
            /**
             * Gets the set of selected items in a range.
             *
             * This function is an optimization for
             * [method`Gtk`.SelectionModel.get_selection] when you are only
             * interested in part of the model's selected state. A common use
             * case is in response to the [signal`Gtk`.SelectionModel::selection-changed]
             * signal.
             * @param position start of the queried range
             * @param n_items number of items in the queried range
             */
            vfunc_get_selection_in_range(position: number, n_items: number): Bitset;
            /**
             * Checks if the given item is selected.
             * @param position the position of the item to query
             */
            vfunc_is_selected(position: number): boolean;
            /**
             * Requests to select all items in the model.
             */
            vfunc_select_all(): boolean;
            /**
             * Requests to select an item in the model.
             * @param position the position of the item to select
             * @param unselect_rest whether previously selected items should be unselected
             */
            vfunc_select_item(position: number, unselect_rest: boolean): boolean;
            /**
             * Requests to select a range of items in the model.
             * @param position the first item to select
             * @param n_items the number of items to select
             * @param unselect_rest whether previously selected items should be unselected
             */
            vfunc_select_range(position: number, n_items: number, unselect_rest: boolean): boolean;
            /**
             * Make selection changes.
             *
             * This is the most advanced selection updating method that allows
             * the most fine-grained control over selection changes. If you can,
             * you should try the simpler versions, as implementations are more
             * likely to implement support for those.
             *
             * Requests that the selection state of all positions set in `mask`
             * be updated to the respective value in the `selected` bitmask.
             *
             * In pseudocode, it would look something like this:
             *
             * ```c
             * for (i = 0; i < n_items; i++)
             *   {
             *     // don't change values not in the mask
             *     if (!gtk_bitset_contains (mask, i))
             *       continue;
             *
             *     if (gtk_bitset_contains (selected, i))
             *       select_item (i);
             *     else
             *       unselect_item (i);
             *   }
             *
             * gtk_selection_model_selection_changed (model,
             *                                        first_changed_item,
             *                                        n_changed_items);
             * ```
             *
             * `mask` and `selected` must not be modified. They may refer to the
             * same bitset, which would mean that every item in the set should
             * be selected.
             * @param selected bitmask specifying if items should be selected or unselected
             * @param mask bitmask specifying which items should be updated
             */
            vfunc_set_selection(selected: Bitset, mask: Bitset): boolean;
            /**
             * Requests to unselect all items in the model.
             */
            vfunc_unselect_all(): boolean;
            /**
             * Requests to unselect an item in the model.
             * @param position the position of the item to unselect
             */
            vfunc_unselect_item(position: number): boolean;
            /**
             * Requests to unselect a range of items in the model.
             * @param position the first item to unselect
             * @param n_items the number of items to unselect
             */
            vfunc_unselect_range(position: number, n_items: number): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace MultiSorter {
            // Constructor properties interface

            interface ConstructorProps<A extends GObject.Object = GObject.Object>
                extends Sorter.ConstructorProps,
                    Gio.ListModel.ConstructorProps,
                    Buildable.ConstructorProps {
                item_type: GObject.GType;
                itemType: GObject.GType;
                n_items: number;
                nItems: number;
            }
        }

        /**
         * `GtkMultiSorter` combines multiple sorters by trying them
         * in turn.
         *
         * If the first sorter compares two items as equal,
         * the second is tried next, and so on.
         */
        class MultiSorter<A extends GObject.Object = GObject.Object>
            extends Sorter
            implements Gio.ListModel<A>, Buildable
        {
            static $gtype: GObject.GType<MultiSorter>;

            // Properties

            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get item_type(): GObject.GType;
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get itemType(): GObject.GType;
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get n_items(): number;
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get nItems(): number;

            // Constructors

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

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

            static ['new'](): MultiSorter;

            // Methods

            /**
             * Add `sorter` to `self` to use for sorting at the end.
             *
             * `self` will consult all existing sorters before it will
             * sort with the given `sorter`.
             * @param sorter a sorter to add
             */
            append(sorter: Sorter): void;
            /**
             * Removes the sorter at the given `position` from the list of sorter
             * used by `self`.
             *
             * If `position` is larger than the number of sorters, nothing happens.
             * @param position position of sorter to remove
             */
            remove(position: number): void;

            // Inherited methods
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             * @returns the #GType of the items contained in @list.
             */
            get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             * @returns the number of items in @list.
             */
            get_n_items(): number;
            /**
             * Get the item at `position`.
             *
             * If `position` is greater than the number of items in `list,` %NULL is
             * returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.
             *
             * This function is meant to be used by language bindings in place
             * of g_list_model_get_item().
             *
             * See also: g_list_model_get_n_items()
             * @param position the position of the item to fetch
             * @returns the object at @position.
             */
            get_item(position: number): A | null;
            /**
             * Emits the #GListModel::items-changed signal on `list`.
             *
             * This function should only be called by classes implementing
             * #GListModel. It has to be called after the internal representation
             * of `list` has been updated, because handlers connected to this signal
             * might query the new state of the list.
             *
             * Implementations must only make changes to the model (as visible to
             * its consumer) in places that will not cause problems for that
             * consumer.  For models that are driven directly by a write API (such
             * as #GListStore), changes can be reported in response to uses of that
             * API.  For models that represent remote data, changes should only be
             * made from a fresh mainloop dispatch.  It is particularly not
             * permitted to make changes in response to a call to the #GListModel
             * consumer API.
             *
             * Stated another way: in general, it is assumed that code making a
             * series of accesses to the model via the API, without returning to the
             * mainloop, and without calling other code, will continue to view the
             * same contents of the model.
             * @param position the position at which @list changed
             * @param removed the number of items removed
             * @param added the number of items added
             */
            items_changed(position: number, removed: number, added: number): void;
            /**
             * Get the item at `position`. If `position` is greater than the number of
             * items in `list,` %NULL is returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.  See g_list_model_get_n_items().
             *
             * The same #GObject instance may not appear more than once in a #GListModel.
             * @param position the position of the item to fetch
             */
            vfunc_get_item(position: number): A | null;
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             */
            vfunc_get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             */
            vfunc_get_n_items(): number;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace NamedAction {
            // Constructor properties interface

            interface ConstructorProps extends ShortcutAction.ConstructorProps {
                action_name: string;
                actionName: string;
            }
        }

        /**
         * A `GtkShortcutAction` that activates an action by name.
         */
        class NamedAction extends ShortcutAction {
            static $gtype: GObject.GType<NamedAction>;

            // Properties

            /**
             * The name of the action to activate.
             */
            get action_name(): string;
            /**
             * The name of the action to activate.
             */
            get actionName(): string;

            // Constructors

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

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

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

            // Methods

            /**
             * Returns the name of the action that will be activated.
             * @returns the name of the action to activate
             */
            get_action_name(): string;
        }

        namespace NativeDialog {
            // Signal callback interfaces

            interface Response {
                (response_id: number): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                modal: boolean;
                title: string;
                transient_for: Window;
                transientFor: Window;
                visible: boolean;
            }
        }

        /**
         * Native dialogs are platform dialogs that don't use `GtkDialog`.
         *
         * They are used in order to integrate better with a platform, by
         * looking the same as other native applications and supporting
         * platform specific features.
         *
         * The [class`Gtk`.Dialog] functions cannot be used on such objects,
         * but we need a similar API in order to drive them. The `GtkNativeDialog`
         * object is an API that allows you to do this. It allows you to set
         * various common properties on the dialog, as well as show and hide
         * it and get a [signal`Gtk`.NativeDialog::response] signal when the user
         * finished with the dialog.
         *
         * Note that unlike `GtkDialog`, `GtkNativeDialog` objects are not
         * toplevel widgets, and GTK does not keep them alive. It is your
         * responsibility to keep a reference until you are done with the
         * object.
         */
        abstract class NativeDialog extends GObject.Object {
            static $gtype: GObject.GType<NativeDialog>;

            // Properties

            /**
             * Whether the window should be modal with respect to its transient parent.
             */
            get modal(): boolean;
            set modal(val: boolean);
            /**
             * The title of the dialog window
             */
            get title(): string;
            set title(val: string);
            /**
             * The transient parent of the dialog, or %NULL for none.
             */
            get transient_for(): Window;
            set transient_for(val: Window);
            /**
             * The transient parent of the dialog, or %NULL for none.
             */
            get transientFor(): Window;
            set transientFor(val: Window);
            /**
             * Whether the window is currently visible.
             */
            get visible(): boolean;
            set visible(val: boolean);

            // Constructors

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

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

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'response', callback: (_source: this, response_id: number) => void): number;
            connect_after(signal: 'response', callback: (_source: this, response_id: number) => void): number;
            emit(signal: 'response', response_id: number): void;

            // Virtual methods

            /**
             * Hides the dialog if it is visible, aborting any interaction.
             *
             * Once this is called the [signal`Gtk`.NativeDialog::response] signal
             * will *not* be emitted until after the next call to
             * [method`Gtk`.NativeDialog.show].
             *
             * If the dialog is not visible this does nothing.
             */
            vfunc_hide(): void;
            /**
             * class handler for the `GtkNativeDialog::response` signal
             * @param response_id
             */
            vfunc_response(response_id: number): void;
            /**
             * Shows the dialog on the display.
             *
             * When the user accepts the state of the dialog the dialog will
             * be automatically hidden and the [signal`Gtk`.NativeDialog::response]
             * signal will be emitted.
             *
             * Multiple calls while the dialog is visible will be ignored.
             */
            vfunc_show(): void;

            // Methods

            /**
             * Destroys a dialog.
             *
             * When a dialog is destroyed, it will break any references it holds
             * to other objects.
             *
             * If it is visible it will be hidden and any underlying window system
             * resources will be destroyed.
             *
             * Note that this does not release any reference to the object (as opposed
             * to destroying a `GtkWindow`) because there is no reference from the
             * windowing system to the `GtkNativeDialog`.
             */
            destroy(): void;
            /**
             * Returns whether the dialog is modal.
             * @returns %TRUE if the dialog is set to be modal
             */
            get_modal(): boolean;
            /**
             * Gets the title of the `GtkNativeDialog`.
             * @returns the title of the dialog, or %NULL if none has    been set explicitly. The returned string is owned by the widget    and must not be modified or freed.
             */
            get_title(): string | null;
            /**
             * Fetches the transient parent for this window.
             * @returns the transient parent for this window,   or %NULL if no transient parent has been set.
             */
            get_transient_for(): Window | null;
            /**
             * Determines whether the dialog is visible.
             * @returns %TRUE if the dialog is visible
             */
            get_visible(): boolean;
            /**
             * Hides the dialog if it is visible, aborting any interaction.
             *
             * Once this is called the [signal`Gtk`.NativeDialog::response] signal
             * will *not* be emitted until after the next call to
             * [method`Gtk`.NativeDialog.show].
             *
             * If the dialog is not visible this does nothing.
             */
            hide(): void;
            /**
             * Sets a dialog modal or non-modal.
             *
             * Modal dialogs prevent interaction with other windows in the same
             * application. To keep modal dialogs on top of main application
             * windows, use [method`Gtk`.NativeDialog.set_transient_for] to make
             * the dialog transient for the parent; most window managers will
             * then disallow lowering the dialog below the parent.
             * @param modal whether the window is modal
             */
            set_modal(modal: boolean): void;
            /**
             * Sets the title of the `GtkNativeDialog.`
             * @param title title of the dialog
             */
            set_title(title: string): void;
            /**
             * Dialog windows should be set transient for the main application
             * window they were spawned from.
             *
             * This allows window managers to e.g. keep the dialog on top of the
             * main window, or center the dialog over the main window.
             *
             * Passing %NULL for `parent` unsets the current transient window.
             * @param parent parent window
             */
            set_transient_for(parent?: Window | null): void;
            /**
             * Shows the dialog on the display.
             *
             * When the user accepts the state of the dialog the dialog will
             * be automatically hidden and the [signal`Gtk`.NativeDialog::response]
             * signal will be emitted.
             *
             * Multiple calls while the dialog is visible will be ignored.
             */
            show(): void;
        }

        namespace NeverTrigger {
            // Constructor properties interface

            interface ConstructorProps extends ShortcutTrigger.ConstructorProps {}
        }

        /**
         * A `GtkShortcutTrigger` that never triggers.
         */
        class NeverTrigger extends ShortcutTrigger {
            static $gtype: GObject.GType<NeverTrigger>;

            // Constructors

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

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

            // Static methods

            /**
             * Gets the never trigger.
             *
             * This is a singleton for a trigger that never triggers.
             * Use this trigger instead of %NULL because it implements
             * all virtual functions.
             */
            static get(): NeverTrigger;
        }

        namespace NoSelection {
            // Constructor properties interface

            interface ConstructorProps<A extends GObject.Object = GObject.Object>
                extends GObject.Object.ConstructorProps,
                    Gio.ListModel.ConstructorProps,
                    SectionModel.ConstructorProps,
                    SelectionModel.ConstructorProps {
                item_type: GObject.GType;
                itemType: GObject.GType;
                model: Gio.ListModel;
                n_items: number;
                nItems: number;
            }
        }

        /**
         * `GtkNoSelection` is a `GtkSelectionModel` that does not allow selecting
         * anything.
         *
         * This model is meant to be used as a simple wrapper around a `GListModel`
         * when a `GtkSelectionModel` is required.
         *
         * `GtkNoSelection` passes through sections from the underlying model.
         */
        class NoSelection<A extends GObject.Object = GObject.Object>
            extends GObject.Object
            implements Gio.ListModel<A>, SectionModel, SelectionModel
        {
            static $gtype: GObject.GType<NoSelection>;

            // Properties

            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get item_type(): GObject.GType;
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get itemType(): GObject.GType;
            /**
             * The model being managed.
             */
            get model(): Gio.ListModel;
            set model(val: Gio.ListModel);
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get n_items(): number;
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get nItems(): number;

            // Constructors

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

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

            static ['new'](model?: Gio.ListModel | null): NoSelection;

            // Methods

            /**
             * Gets the model that `self` is wrapping.
             * @returns The model being wrapped
             */
            get_model(): Gio.ListModel | null;
            /**
             * Sets the model that `self` should wrap.
             *
             * If `model` is %NULL, this model will be empty.
             * @param model A `GListModel` to wrap
             */
            set_model(model?: Gio.ListModel | null): void;

            // Inherited methods
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             * @returns the #GType of the items contained in @list.
             */
            get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             * @returns the number of items in @list.
             */
            get_n_items(): number;
            /**
             * Get the item at `position`.
             *
             * If `position` is greater than the number of items in `list,` %NULL is
             * returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.
             *
             * This function is meant to be used by language bindings in place
             * of g_list_model_get_item().
             *
             * See also: g_list_model_get_n_items()
             * @param position the position of the item to fetch
             * @returns the object at @position.
             */
            get_item(position: number): A | null;
            /**
             * Emits the #GListModel::items-changed signal on `list`.
             *
             * This function should only be called by classes implementing
             * #GListModel. It has to be called after the internal representation
             * of `list` has been updated, because handlers connected to this signal
             * might query the new state of the list.
             *
             * Implementations must only make changes to the model (as visible to
             * its consumer) in places that will not cause problems for that
             * consumer.  For models that are driven directly by a write API (such
             * as #GListStore), changes can be reported in response to uses of that
             * API.  For models that represent remote data, changes should only be
             * made from a fresh mainloop dispatch.  It is particularly not
             * permitted to make changes in response to a call to the #GListModel
             * consumer API.
             *
             * Stated another way: in general, it is assumed that code making a
             * series of accesses to the model via the API, without returning to the
             * mainloop, and without calling other code, will continue to view the
             * same contents of the model.
             * @param position the position at which @list changed
             * @param removed the number of items removed
             * @param added the number of items added
             */
            items_changed(position: number, removed: number, added: number): void;
            /**
             * Get the item at `position`. If `position` is greater than the number of
             * items in `list,` %NULL is returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.  See g_list_model_get_n_items().
             *
             * The same #GObject instance may not appear more than once in a #GListModel.
             * @param position the position of the item to fetch
             */
            vfunc_get_item(position: number): A | null;
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             */
            vfunc_get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             */
            vfunc_get_n_items(): number;
            /**
             * Query the section that covers the given position. The number of
             * items in the section can be computed by `out_end - out_start`.
             *
             * If the position is larger than the number of items, a single
             * range from n_items to G_MAXUINT will be returned.
             * @param position the position of the item to query
             */
            get_section(position: number): [number, number];
            /**
             * This function emits the [signal`Gtk`.SectionModel::sections-changed]
             * signal to notify about changes to sections.
             *
             * It must cover all positions that used to be a section start or that
             * are now a section start. It does not have to cover all positions for
             * which the section has changed.
             *
             * The [signal`Gio`.ListModel::items-changed] implies the effect of the
             * [signal`Gtk`.SectionModel::sections-changed] signal for all the items
             * it covers.
             *
             * It is recommended that when changes to the items cause section changes
             * in a larger range, that the larger range is included in the emission
             * of the [signal`Gio`.ListModel::items-changed] instead of emitting
             * two signals.
             * @param position the first changed item
             * @param n_items the number of changed items
             */
            sections_changed(position: number, n_items: number): void;
            /**
             * Query the section that covers the given position. The number of
             * items in the section can be computed by `out_end - out_start`.
             *
             * If the position is larger than the number of items, a single
             * range from n_items to G_MAXUINT will be returned.
             * @param position the position of the item to query
             */
            vfunc_get_section(position: number): [number, number];
            /**
             * Gets the set containing all currently selected items in the model.
             *
             * This function may be slow, so if you are only interested in single item,
             * consider using [method`Gtk`.SelectionModel.is_selected] or if you are only
             * interested in a few, consider [method`Gtk`.SelectionModel.get_selection_in_range].
             * @returns a `GtkBitset` containing all the values currently   selected in @model. If no items are selected, the bitset is empty.   The bitset must not be modified.
             */
            get_selection(): Bitset;
            /**
             * Gets the set of selected items in a range.
             *
             * This function is an optimization for
             * [method`Gtk`.SelectionModel.get_selection] when you are only
             * interested in part of the model's selected state. A common use
             * case is in response to the [signal`Gtk`.SelectionModel::selection-changed]
             * signal.
             * @param position start of the queried range
             * @param n_items number of items in the queried range
             * @returns A `GtkBitset` that matches the selection state   for the given range with all other values being undefined.   The bitset must not be modified.
             */
            get_selection_in_range(position: number, n_items: number): Bitset;
            /**
             * Checks if the given item is selected.
             * @param position the position of the item to query
             * @returns %TRUE if the item is selected
             */
            is_selected(position: number): boolean;
            /**
             * Requests to select all items in the model.
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items are now selected.
             */
            select_all(): boolean;
            /**
             * Requests to select an item in the model.
             * @param position the position of the item to select
             * @param unselect_rest whether previously selected items should be unselected
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the item was selected.
             */
            select_item(position: number, unselect_rest: boolean): boolean;
            /**
             * Requests to select a range of items in the model.
             * @param position the first item to select
             * @param n_items the number of items to select
             * @param unselect_rest whether previously selected items should be unselected
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the range was selected.
             */
            select_range(position: number, n_items: number, unselect_rest: boolean): boolean;
            /**
             * Helper function for implementations of `GtkSelectionModel`.
             *
             * Call this when the selection changes to emit the
             * [signal`Gtk`.SelectionModel::selection-changed] signal.
             * @param position the first changed item
             * @param n_items the number of changed items
             */
            selection_changed(position: number, n_items: number): void;
            /**
             * Make selection changes.
             *
             * This is the most advanced selection updating method that allows
             * the most fine-grained control over selection changes. If you can,
             * you should try the simpler versions, as implementations are more
             * likely to implement support for those.
             *
             * Requests that the selection state of all positions set in `mask`
             * be updated to the respective value in the `selected` bitmask.
             *
             * In pseudocode, it would look something like this:
             *
             * ```c
             * for (i = 0; i < n_items; i++)
             *   {
             *     // don't change values not in the mask
             *     if (!gtk_bitset_contains (mask, i))
             *       continue;
             *
             *     if (gtk_bitset_contains (selected, i))
             *       select_item (i);
             *     else
             *       unselect_item (i);
             *   }
             *
             * gtk_selection_model_selection_changed (model,
             *                                        first_changed_item,
             *                                        n_changed_items);
             * ```
             *
             * `mask` and `selected` must not be modified. They may refer to the
             * same bitset, which would mean that every item in the set should
             * be selected.
             * @param selected bitmask specifying if items should be selected or unselected
             * @param mask bitmask specifying which items should be updated
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items were updated according   to the inputs.
             */
            set_selection(selected: Bitset, mask: Bitset): boolean;
            /**
             * Requests to unselect all items in the model.
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items are now unselected.
             */
            unselect_all(): boolean;
            /**
             * Requests to unselect an item in the model.
             * @param position the position of the item to unselect
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the item was unselected.
             */
            unselect_item(position: number): boolean;
            /**
             * Requests to unselect a range of items in the model.
             * @param position the first item to unselect
             * @param n_items the number of items to unselect
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the range was unselected.
             */
            unselect_range(position: number, n_items: number): boolean;
            /**
             * Gets the set of selected items in a range.
             *
             * This function is an optimization for
             * [method`Gtk`.SelectionModel.get_selection] when you are only
             * interested in part of the model's selected state. A common use
             * case is in response to the [signal`Gtk`.SelectionModel::selection-changed]
             * signal.
             * @param position start of the queried range
             * @param n_items number of items in the queried range
             */
            vfunc_get_selection_in_range(position: number, n_items: number): Bitset;
            /**
             * Checks if the given item is selected.
             * @param position the position of the item to query
             */
            vfunc_is_selected(position: number): boolean;
            /**
             * Requests to select all items in the model.
             */
            vfunc_select_all(): boolean;
            /**
             * Requests to select an item in the model.
             * @param position the position of the item to select
             * @param unselect_rest whether previously selected items should be unselected
             */
            vfunc_select_item(position: number, unselect_rest: boolean): boolean;
            /**
             * Requests to select a range of items in the model.
             * @param position the first item to select
             * @param n_items the number of items to select
             * @param unselect_rest whether previously selected items should be unselected
             */
            vfunc_select_range(position: number, n_items: number, unselect_rest: boolean): boolean;
            /**
             * Make selection changes.
             *
             * This is the most advanced selection updating method that allows
             * the most fine-grained control over selection changes. If you can,
             * you should try the simpler versions, as implementations are more
             * likely to implement support for those.
             *
             * Requests that the selection state of all positions set in `mask`
             * be updated to the respective value in the `selected` bitmask.
             *
             * In pseudocode, it would look something like this:
             *
             * ```c
             * for (i = 0; i < n_items; i++)
             *   {
             *     // don't change values not in the mask
             *     if (!gtk_bitset_contains (mask, i))
             *       continue;
             *
             *     if (gtk_bitset_contains (selected, i))
             *       select_item (i);
             *     else
             *       unselect_item (i);
             *   }
             *
             * gtk_selection_model_selection_changed (model,
             *                                        first_changed_item,
             *                                        n_changed_items);
             * ```
             *
             * `mask` and `selected` must not be modified. They may refer to the
             * same bitset, which would mean that every item in the set should
             * be selected.
             * @param selected bitmask specifying if items should be selected or unselected
             * @param mask bitmask specifying which items should be updated
             */
            vfunc_set_selection(selected: Bitset, mask: Bitset): boolean;
            /**
             * Requests to unselect all items in the model.
             */
            vfunc_unselect_all(): boolean;
            /**
             * Requests to unselect an item in the model.
             * @param position the position of the item to unselect
             */
            vfunc_unselect_item(position: number): boolean;
            /**
             * Requests to unselect a range of items in the model.
             * @param position the first item to unselect
             * @param n_items the number of items to unselect
             */
            vfunc_unselect_range(position: number, n_items: number): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Notebook {
            // Signal callback interfaces

            interface ChangeCurrentPage {
                (page: number): boolean;
            }

            interface CreateWindow {
                (page: Widget): Notebook | null;
            }

            interface FocusTab {
                (tab: NotebookTab): boolean;
            }

            interface MoveFocusOut {
                (direction: DirectionType): void;
            }

            interface PageAdded {
                (child: Widget, page_num: number): void;
            }

            interface PageRemoved {
                (child: Widget, page_num: number): void;
            }

            interface PageReordered {
                (child: Widget, page_num: number): void;
            }

            interface ReorderTab {
                (direction: DirectionType, move_to_last: boolean): boolean;
            }

            interface SelectPage {
                (move_focus: boolean): boolean;
            }

            interface SwitchPage {
                (page: Widget, page_num: number): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                enable_popup: boolean;
                enablePopup: boolean;
                group_name: string;
                groupName: string;
                page: number;
                pages: Gio.ListModel;
                scrollable: boolean;
                show_border: boolean;
                showBorder: boolean;
                show_tabs: boolean;
                showTabs: boolean;
                tab_pos: PositionType;
                tabPos: PositionType;
            }
        }

        /**
         * `GtkNotebook` is a container whose children are pages switched
         * between using tabs.
         *
         * ![An example GtkNotebook](notebook.png)
         *
         * There are many configuration options for `GtkNotebook`. Among
         * other things, you can choose on which edge the tabs appear
         * (see [method`Gtk`.Notebook.set_tab_pos]), whether, if there are
         * too many tabs to fit the notebook should be made bigger or scrolling
         * arrows added (see [method`Gtk`.Notebook.set_scrollable]), and whether
         * there will be a popup menu allowing the users to switch pages.
         * (see [method`Gtk`.Notebook.popup_enable]).
         *
         * # GtkNotebook as GtkBuildable
         *
         * The `GtkNotebook` implementation of the `GtkBuildable` interface
         * supports placing children into tabs by specifying “tab” as the
         * “type” attribute of a `<child>` element. Note that the content
         * of the tab must be created before the tab can be filled.
         * A tab child can be specified without specifying a `<child>`
         * type attribute.
         *
         * To add a child widget in the notebooks action area, specify
         * "action-start" or “action-end” as the “type” attribute of the
         * `<child>` element.
         *
         * An example of a UI definition fragment with `GtkNotebook`:
         *
         * ```xml
         * <object class="GtkNotebook">
         *   <child>
         *     <object class="GtkLabel" id="notebook-content">
         *       <property name="label">Content</property>
         *     </object>
         *   </child>
         *   <child type="tab">
         *     <object class="GtkLabel" id="notebook-tab">
         *       <property name="label">Tab</property>
         *     </object>
         *   </child>
         * </object>
         * ```
         *
         * # Shortcuts and Gestures
         *
         * `GtkNotebook` supports the following keyboard shortcuts:
         *
         * - <kbd>Shift</kbd>+<kbd>F10</kbd> or <kbd>Menu</kbd> opens the context menu.
         * - <kbd>Home</kbd> moves the focus to the first tab.
         * - <kbd>End</kbd> moves the focus to the last tab.
         *
         * Additionally, the following signals have default keybindings:
         *
         * - [signal`Gtk`.Notebook::change-current-page]
         * - [signal`Gtk`.Notebook::focus-tab]
         * - [signal`Gtk`.Notebook::move-focus-out]
         * - [signal`Gtk`.Notebook::reorder-tab]
         * - [signal`Gtk`.Notebook::select-page]
         *
         * Tabs support drag-and-drop between notebooks sharing the same `group-name`,
         * or to new windows by handling the `::create-window` signal.
         *
         * # Actions
         *
         * `GtkNotebook` defines a set of built-in actions:
         *
         * - `menu.popup` opens the tabs context menu.
         *
         * # CSS nodes
         *
         * ```
         * notebook
         * ├── header.top
         * │   ├── [<action widget>]
         * │   ├── tabs
         * │   │   ├── [arrow]
         * │   │   ├── tab
         * │   │   │   ╰── <tab label>
         * ┊   ┊   ┊
         * │   │   ├── tab[.reorderable-page]
         * │   │   │   ╰── <tab label>
         * │   │   ╰── [arrow]
         * │   ╰── [<action widget>]
         * │
         * ╰── stack
         *     ├── <child>
         *     ┊
         *     ╰── <child>
         * ```
         *
         * `GtkNotebook` has a main CSS node with name `notebook`, a subnode
         * with name `header` and below that a subnode with name `tabs` which
         * contains one subnode per tab with name `tab`.
         *
         * If action widgets are present, their CSS nodes are placed next
         * to the `tabs` node. If the notebook is scrollable, CSS nodes with
         * name `arrow` are placed as first and last child of the `tabs` node.
         *
         * The main node gets the `.frame` style class when the notebook
         * has a border (see [method`Gtk`.Notebook.set_show_border]).
         *
         * The header node gets one of the style class `.top`, `.bottom`,
         * `.left` or `.right`, depending on where the tabs are placed. For
         * reorderable pages, the tab node gets the `.reorderable-page` class.
         *
         * A `tab` node gets the `.dnd` style class while it is moved with drag-and-drop.
         *
         * The nodes are always arranged from left-to-right, regardless of text direction.
         *
         * # Accessibility
         *
         * `GtkNotebook` uses the following roles:
         *
         *  - %GTK_ACCESSIBLE_ROLE_GROUP for the notebook widget
         *  - %GTK_ACCESSIBLE_ROLE_TAB_LIST for the list of tabs
         *  - %GTK_ACCESSIBLE_ROLE_TAB role for each tab
         *  - %GTK_ACCESSIBLE_ROLE_TAB_PANEL for each page
         */
        class Notebook extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<Notebook>;

            // Properties

            /**
             * If %TRUE, pressing the right mouse button on the notebook shows a page switching menu.
             */
            get enable_popup(): boolean;
            set enable_popup(val: boolean);
            /**
             * If %TRUE, pressing the right mouse button on the notebook shows a page switching menu.
             */
            get enablePopup(): boolean;
            set enablePopup(val: boolean);
            /**
             * Group name for tab drag and drop.
             */
            get group_name(): string;
            set group_name(val: string);
            /**
             * Group name for tab drag and drop.
             */
            get groupName(): string;
            set groupName(val: string);
            /**
             * The index of the current page.
             */
            get page(): number;
            set page(val: number);
            /**
             * A selection model with the pages.
             */
            get pages(): Gio.ListModel;
            /**
             * If %TRUE, scroll arrows are added if there are too many pages to fit.
             */
            get scrollable(): boolean;
            set scrollable(val: boolean);
            /**
             * Whether the border should be shown.
             */
            get show_border(): boolean;
            set show_border(val: boolean);
            /**
             * Whether the border should be shown.
             */
            get showBorder(): boolean;
            set showBorder(val: boolean);
            /**
             * Whether tabs should be shown.
             */
            get show_tabs(): boolean;
            set show_tabs(val: boolean);
            /**
             * Whether tabs should be shown.
             */
            get showTabs(): boolean;
            set showTabs(val: boolean);
            /**
             * Which side of the notebook holds the tabs.
             */
            get tab_pos(): PositionType;
            set tab_pos(val: PositionType);
            /**
             * Which side of the notebook holds the tabs.
             */
            get tabPos(): PositionType;
            set tabPos(val: PositionType);

            // Constructors

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

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

            static ['new'](): Notebook;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'change-current-page', callback: (_source: this, page: number) => boolean): number;
            connect_after(signal: 'change-current-page', callback: (_source: this, page: number) => boolean): number;
            emit(signal: 'change-current-page', page: number): void;
            connect(signal: 'create-window', callback: (_source: this, page: Widget) => Notebook | null): number;
            connect_after(signal: 'create-window', callback: (_source: this, page: Widget) => Notebook | null): number;
            emit(signal: 'create-window', page: Widget): void;
            connect(signal: 'focus-tab', callback: (_source: this, tab: NotebookTab) => boolean): number;
            connect_after(signal: 'focus-tab', callback: (_source: this, tab: NotebookTab) => boolean): number;
            emit(signal: 'focus-tab', tab: NotebookTab): void;
            connect(signal: 'move-focus-out', callback: (_source: this, direction: DirectionType) => void): number;
            connect_after(
                signal: 'move-focus-out',
                callback: (_source: this, direction: DirectionType) => void,
            ): number;
            emit(signal: 'move-focus-out', direction: DirectionType): void;
            connect(signal: 'page-added', callback: (_source: this, child: Widget, page_num: number) => void): number;
            connect_after(
                signal: 'page-added',
                callback: (_source: this, child: Widget, page_num: number) => void,
            ): number;
            emit(signal: 'page-added', child: Widget, page_num: number): void;
            connect(signal: 'page-removed', callback: (_source: this, child: Widget, page_num: number) => void): number;
            connect_after(
                signal: 'page-removed',
                callback: (_source: this, child: Widget, page_num: number) => void,
            ): number;
            emit(signal: 'page-removed', child: Widget, page_num: number): void;
            connect(
                signal: 'page-reordered',
                callback: (_source: this, child: Widget, page_num: number) => void,
            ): number;
            connect_after(
                signal: 'page-reordered',
                callback: (_source: this, child: Widget, page_num: number) => void,
            ): number;
            emit(signal: 'page-reordered', child: Widget, page_num: number): void;
            connect(
                signal: 'reorder-tab',
                callback: (_source: this, direction: DirectionType, move_to_last: boolean) => boolean,
            ): number;
            connect_after(
                signal: 'reorder-tab',
                callback: (_source: this, direction: DirectionType, move_to_last: boolean) => boolean,
            ): number;
            emit(signal: 'reorder-tab', direction: DirectionType, move_to_last: boolean): void;
            connect(signal: 'select-page', callback: (_source: this, move_focus: boolean) => boolean): number;
            connect_after(signal: 'select-page', callback: (_source: this, move_focus: boolean) => boolean): number;
            emit(signal: 'select-page', move_focus: boolean): void;
            connect(signal: 'switch-page', callback: (_source: this, page: Widget, page_num: number) => void): number;
            connect_after(
                signal: 'switch-page',
                callback: (_source: this, page: Widget, page_num: number) => void,
            ): number;
            emit(signal: 'switch-page', page: Widget, page_num: number): void;

            // Methods

            /**
             * Appends a page to `notebook`.
             * @param child the `GtkWidget` to use as the contents of the page
             * @param tab_label the `GtkWidget` to be used as the label   for the page, or %NULL to use the default label, “page N”
             * @returns the index (starting from 0) of the appended   page in the notebook, or -1 if function fails
             */
            append_page(child: Widget, tab_label?: Widget | null): number;
            /**
             * Appends a page to `notebook,` specifying the widget to use as the
             * label in the popup menu.
             * @param child the `GtkWidget` to use as the contents of the page
             * @param tab_label the `GtkWidget` to be used as the label   for the page, or %NULL to use the default label, “page N”
             * @param menu_label the widget to use as a label for the   page-switch menu, if that is enabled. If %NULL, and @tab_label   is a `GtkLabel` or %NULL, then the menu label will be a newly   created label with the same text as @tab_label; if @tab_label   is not a `GtkLabel`, @menu_label must be specified if the   page-switch menu is to be used.
             * @returns the index (starting from 0) of the appended   page in the notebook, or -1 if function fails
             */
            append_page_menu(child: Widget, tab_label?: Widget | null, menu_label?: Widget | null): number;
            /**
             * Removes the child from the notebook.
             *
             * This function is very similar to [method`Gtk`.Notebook.remove_page],
             * but additionally informs the notebook that the removal
             * is happening as part of a tab DND operation, which should
             * not be cancelled.
             * @param child a child
             */
            detach_tab(child: Widget): void;
            /**
             * Gets one of the action widgets.
             *
             * See [method`Gtk`.Notebook.set_action_widget].
             * @param pack_type pack type of the action widget to receive
             * @returns The action widget   with the given @pack_type or %NULL when this action   widget has not been set
             */
            get_action_widget(pack_type: PackType | null): Widget | null;
            /**
             * Returns the page number of the current page.
             * @returns the index (starting from 0) of the current   page in the notebook. If the notebook has no pages,   then -1 will be returned.
             */
            get_current_page(): number;
            /**
             * Gets the current group name for `notebook`.
             * @returns the group name,   or %NULL if none is set
             */
            get_group_name(): string | null;
            /**
             * Retrieves the menu label widget of the page containing `child`.
             * @param child a widget contained in a page of @notebook
             * @returns the menu label, or %NULL   if the notebook page does not have a menu label other than   the default (the tab label).
             */
            get_menu_label(child: Widget): Widget | null;
            /**
             * Retrieves the text of the menu label for the page containing
             * `child`.
             * @param child the child widget of a page of the notebook.
             * @returns the text of the tab label, or %NULL if   the widget does not have a menu label other than the default   menu label, or the menu label widget is not a `GtkLabel`.   The string is owned by the widget and must not be freed.
             */
            get_menu_label_text(child: Widget): string | null;
            /**
             * Gets the number of pages in a notebook.
             * @returns the number of pages in the notebook
             */
            get_n_pages(): number;
            /**
             * Returns the child widget contained in page number `page_num`.
             * @param page_num the index of a page in the notebook, or -1   to get the last page
             * @returns the child widget, or %NULL if @page_num is out of bounds
             */
            get_nth_page(page_num: number): Widget | null;
            /**
             * Returns the `GtkNotebookPage` for `child`.
             * @param child a child of @notebook
             * @returns the `GtkNotebookPage` for @child
             */
            get_page(child: Widget): NotebookPage;
            /**
             * Returns a `GListModel` that contains the pages of the notebook.
             *
             * This can be used to keep an up-to-date view. The model also
             * implements [iface`Gtk`.SelectionModel] and can be used to track
             * and modify the visible page.
             * @returns a   `GListModel` for the notebook's children
             */
            get_pages(): Gio.ListModel;
            /**
             * Returns whether the tab label area has arrows for scrolling.
             * @returns %TRUE if arrows for scrolling are present
             */
            get_scrollable(): boolean;
            /**
             * Returns whether a bevel will be drawn around the notebook pages.
             * @returns %TRUE if the bevel is drawn
             */
            get_show_border(): boolean;
            /**
             * Returns whether the tabs of the notebook are shown.
             * @returns %TRUE if the tabs are shown
             */
            get_show_tabs(): boolean;
            /**
             * Returns whether the tab contents can be detached from `notebook`.
             * @param child a child `GtkWidget`
             * @returns %TRUE if the tab is detachable.
             */
            get_tab_detachable(child: Widget): boolean;
            /**
             * Returns the tab label widget for the page `child`.
             *
             * %NULL is returned if `child` is not in `notebook` or
             * if no tab label has specifically been set for `child`.
             * @param child the page
             * @returns the tab label
             */
            get_tab_label(child: Widget): Widget | null;
            /**
             * Retrieves the text of the tab label for the page containing
             * `child`.
             * @param child a widget contained in a page of @notebook
             * @returns the text of the tab label, or %NULL if   the tab label widget is not a `GtkLabel`. The string is owned   by the widget and must not be freed.
             */
            get_tab_label_text(child: Widget): string | null;
            /**
             * Gets the edge at which the tabs are drawn.
             * @returns the edge at which the tabs are drawn
             */
            get_tab_pos(): PositionType;
            /**
             * Gets whether the tab can be reordered via drag and drop or not.
             * @param child a child `GtkWidget`
             * @returns %TRUE if the tab is reorderable.
             */
            get_tab_reorderable(child: Widget): boolean;
            /**
             * Insert a page into `notebook` at the given position.
             * @param child the `GtkWidget` to use as the contents of the page
             * @param tab_label the `GtkWidget` to be used as the label   for the page, or %NULL to use the default label, “page N”
             * @param position the index (starting at 0) at which to insert the page,   or -1 to append the page after all other pages
             * @returns the index (starting from 0) of the inserted   page in the notebook, or -1 if function fails
             */
            insert_page(child: Widget, tab_label: Widget | null, position: number): number;
            /**
             * Insert a page into `notebook` at the given position, specifying
             * the widget to use as the label in the popup menu.
             * @param child the `GtkWidget` to use as the contents of the page
             * @param tab_label the `GtkWidget` to be used as the label   for the page, or %NULL to use the default label, “page N”
             * @param menu_label the widget to use as a label for the   page-switch menu, if that is enabled. If %NULL, and @tab_label   is a `GtkLabel` or %NULL, then the menu label will be a newly   created label with the same text as @tab_label; if @tab_label   is not a `GtkLabel`, @menu_label must be specified if the   page-switch menu is to be used.
             * @param position the index (starting at 0) at which to insert the page,   or -1 to append the page after all other pages.
             * @returns the index (starting from 0) of the inserted   page in the notebook
             */
            insert_page_menu(
                child: Widget,
                tab_label: Widget | null,
                menu_label: Widget | null,
                position: number,
            ): number;
            /**
             * Switches to the next page.
             *
             * Nothing happens if the current page is the last page.
             */
            next_page(): void;
            /**
             * Finds the index of the page which contains the given child
             * widget.
             * @param child a `GtkWidget`
             * @returns the index of the page containing @child, or   -1 if @child is not in the notebook
             */
            page_num(child: Widget): number;
            /**
             * Disables the popup menu.
             */
            popup_disable(): void;
            /**
             * Enables the popup menu.
             *
             * If the user clicks with the right mouse button on the tab labels,
             * a menu with all the pages will be popped up.
             */
            popup_enable(): void;
            /**
             * Prepends a page to `notebook`.
             * @param child the `GtkWidget` to use as the contents of the page
             * @param tab_label the `GtkWidget` to be used as the label   for the page, or %NULL to use the default label, “page N”
             * @returns the index (starting from 0) of the prepended   page in the notebook, or -1 if function fails
             */
            prepend_page(child: Widget, tab_label?: Widget | null): number;
            /**
             * Prepends a page to `notebook,` specifying the widget to use as the
             * label in the popup menu.
             * @param child the `GtkWidget` to use as the contents of the page
             * @param tab_label the `GtkWidget` to be used as the label   for the page, or %NULL to use the default label, “page N”
             * @param menu_label the widget to use as a label for the   page-switch menu, if that is enabled. If %NULL, and @tab_label   is a `GtkLabel` or %NULL, then the menu label will be a newly   created label with the same text as @tab_label; if @tab_label   is not a `GtkLabel`, @menu_label must be specified if the   page-switch menu is to be used.
             * @returns the index (starting from 0) of the prepended   page in the notebook, or -1 if function fails
             */
            prepend_page_menu(child: Widget, tab_label?: Widget | null, menu_label?: Widget | null): number;
            /**
             * Switches to the previous page.
             *
             * Nothing happens if the current page is the first page.
             */
            prev_page(): void;
            /**
             * Removes a page from the notebook given its index
             * in the notebook.
             * @param page_num the index of a notebook page, starting   from 0. If -1, the last page will be removed.
             */
            remove_page(page_num: number): void;
            /**
             * Reorders the page containing `child,` so that it appears in position
             * `position`.
             *
             * If `position` is greater than or equal to the number of children in
             * the list or negative, `child` will be moved to the end of the list.
             * @param child the child to move
             * @param position the new position, or -1 to move to the end
             */
            reorder_child(child: Widget, position: number): void;
            /**
             * Sets `widget` as one of the action widgets.
             *
             * Depending on the pack type the widget will be placed before
             * or after the tabs. You can use a `GtkBox` if you need to pack
             * more than one widget on the same side.
             * @param widget a `GtkWidget`
             * @param pack_type pack type of the action widget
             */
            set_action_widget(widget: Widget, pack_type: PackType | null): void;
            /**
             * Switches to the page number `page_num`.
             *
             * Note that due to historical reasons, GtkNotebook refuses
             * to switch to a page unless the child widget is visible.
             * Therefore, it is recommended to show child widgets before
             * adding them to a notebook.
             * @param page_num index of the page to switch to, starting from 0.   If negative, the last page will be used. If greater   than the number of pages in the notebook, nothing   will be done.
             */
            set_current_page(page_num: number): void;
            /**
             * Sets a group name for `notebook`.
             *
             * Notebooks with the same name will be able to exchange tabs
             * via drag and drop. A notebook with a %NULL group name will
             * not be able to exchange tabs with any other notebook.
             * @param group_name the name of the notebook group,   or %NULL to unset it
             */
            set_group_name(group_name?: string | null): void;
            /**
             * Changes the menu label for the page containing `child`.
             * @param child the child widget
             * @param menu_label the menu label, or %NULL for default
             */
            set_menu_label(child: Widget, menu_label?: Widget | null): void;
            /**
             * Creates a new label and sets it as the menu label of `child`.
             * @param child the child widget
             * @param menu_text the label text
             */
            set_menu_label_text(child: Widget, menu_text: string): void;
            /**
             * Sets whether the tab label area will have arrows for
             * scrolling if there are too many tabs to fit in the area.
             * @param scrollable %TRUE if scroll arrows should be added
             */
            set_scrollable(scrollable: boolean): void;
            /**
             * Sets whether a bevel will be drawn around the notebook pages.
             *
             * This only has a visual effect when the tabs are not shown.
             * @param show_border %TRUE if a bevel should be drawn around the notebook
             */
            set_show_border(show_border: boolean): void;
            /**
             * Sets whether to show the tabs for the notebook or not.
             * @param show_tabs %TRUE if the tabs should be shown
             */
            set_show_tabs(show_tabs: boolean): void;
            /**
             * Sets whether the tab can be detached from `notebook` to another
             * notebook or widget.
             *
             * Note that two notebooks must share a common group identifier
             * (see [method`Gtk`.Notebook.set_group_name]) to allow automatic tabs
             * interchange between them.
             *
             * If you want a widget to interact with a notebook through DnD
             * (i.e.: accept dragged tabs from it) it must be set as a drop
             * destination by adding to it a [class`Gtk`.DropTarget] controller that accepts
             * the GType `GTK_TYPE_NOTEBOOK_PAGE`. The `:value` of said drop target will be
             * preloaded with a [class`Gtk`.NotebookPage] object that corresponds to the
             * dropped tab, so you can process the value via `::accept` or `::drop` signals.
             *
             * Note that you should use [method`Gtk`.Notebook.detach_tab] instead
             * of [method`Gtk`.Notebook.remove_page] if you want to remove the tab
             * from the source notebook as part of accepting a drop. Otherwise,
             * the source notebook will think that the dragged tab was removed
             * from underneath the ongoing drag operation, and will initiate a
             * drag cancel animation.
             *
             * ```c
             * static void
             * on_drag_data_received (GtkWidget        *widget,
             *                        GdkDrop          *drop,
             *                        GtkSelectionData *data,
             *                        guint             time,
             *                        gpointer          user_data)
             * {
             *   GtkDrag *drag;
             *   GtkWidget *notebook;
             *   GtkWidget **child;
             *
             *   drag = gtk_drop_get_drag (drop);
             *   notebook = g_object_get_data (drag, "gtk-notebook-drag-origin");
             *   child = (void*) gtk_selection_data_get_data (data);
             *
             *   // process_widget (*child);
             *
             *   gtk_notebook_detach_tab (GTK_NOTEBOOK (notebook), *child);
             * }
             * ```
             *
             * If you want a notebook to accept drags from other widgets,
             * you will have to set your own DnD code to do it.
             * @param child a child `GtkWidget`
             * @param detachable whether the tab is detachable or not
             */
            set_tab_detachable(child: Widget, detachable: boolean): void;
            /**
             * Changes the tab label for `child`.
             *
             * If %NULL is specified for `tab_label,` then the page will
             * have the label “page N”.
             * @param child the page
             * @param tab_label the tab label widget to use, or %NULL   for default tab label
             */
            set_tab_label(child: Widget, tab_label?: Widget | null): void;
            /**
             * Creates a new label and sets it as the tab label for the page
             * containing `child`.
             * @param child the page
             * @param tab_text the label text
             */
            set_tab_label_text(child: Widget, tab_text: string): void;
            /**
             * Sets the edge at which the tabs are drawn.
             * @param pos the edge to draw the tabs at
             */
            set_tab_pos(pos: PositionType | null): void;
            /**
             * Sets whether the notebook tab can be reordered
             * via drag and drop or not.
             * @param child a child `GtkWidget`
             * @param reorderable whether the tab is reorderable or not
             */
            set_tab_reorderable(child: Widget, reorderable: boolean): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace NotebookPage {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                child: Widget;
                detachable: boolean;
                menu: Widget;
                menu_label: string;
                menuLabel: string;
                position: number;
                reorderable: boolean;
                tab: Widget;
                tab_expand: boolean;
                tabExpand: boolean;
                tab_fill: boolean;
                tabFill: boolean;
                tab_label: string;
                tabLabel: string;
            }
        }

        /**
         * `GtkNotebookPage` is an auxiliary object used by `GtkNotebook`.
         */
        class NotebookPage extends GObject.Object {
            static $gtype: GObject.GType<NotebookPage>;

            // Properties

            /**
             * The child for this page.
             */
            get child(): Widget;
            /**
             * Whether the tab is detachable.
             */
            get detachable(): boolean;
            set detachable(val: boolean);
            /**
             * The label widget displayed in the child's menu entry.
             */
            get menu(): Widget;
            /**
             * The text of the menu widget.
             */
            get menu_label(): string;
            set menu_label(val: string);
            /**
             * The text of the menu widget.
             */
            get menuLabel(): string;
            set menuLabel(val: string);
            /**
             * The index of the child in the parent.
             */
            get position(): number;
            set position(val: number);
            /**
             * Whether the tab is reorderable by user action.
             */
            get reorderable(): boolean;
            set reorderable(val: boolean);
            /**
             * The tab widget for this page.
             */
            get tab(): Widget;
            /**
             * Whether to expand the child's tab.
             */
            get tab_expand(): boolean;
            set tab_expand(val: boolean);
            /**
             * Whether to expand the child's tab.
             */
            get tabExpand(): boolean;
            set tabExpand(val: boolean);
            /**
             * Whether the child's tab should fill the allocated area.
             */
            get tab_fill(): boolean;
            set tab_fill(val: boolean);
            /**
             * Whether the child's tab should fill the allocated area.
             */
            get tabFill(): boolean;
            set tabFill(val: boolean);
            /**
             * The text of the tab widget.
             */
            get tab_label(): string;
            set tab_label(val: string);
            /**
             * The text of the tab widget.
             */
            get tabLabel(): string;
            set tabLabel(val: string);

            // Constructors

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

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

            // Methods

            /**
             * Returns the notebook child to which `page` belongs.
             * @returns the child to which @page belongs
             */
            get_child(): Widget;
        }

        namespace NothingAction {
            // Constructor properties interface

            interface ConstructorProps extends ShortcutAction.ConstructorProps {}
        }

        /**
         * A `GtkShortcutAction` that does nothing.
         */
        class NothingAction extends ShortcutAction {
            static $gtype: GObject.GType<NothingAction>;

            // Constructors

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

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

            // Static methods

            /**
             * Gets the nothing action.
             *
             * This is an action that does nothing and where
             * activating it always fails.
             */
            static get(): NothingAction;
        }

        namespace NumericSorter {
            // Constructor properties interface

            interface ConstructorProps extends Sorter.ConstructorProps {
                expression: Expression;
                sort_order: SortType;
                sortOrder: SortType;
            }
        }

        /**
         * `GtkNumericSorter` is a `GtkSorter` that compares numbers.
         *
         * To obtain the numbers to compare, this sorter evaluates a
         * [class`Gtk`.Expression].
         */
        class NumericSorter extends Sorter {
            static $gtype: GObject.GType<NumericSorter>;

            // Properties

            /**
             * The expression to evaluate on items to get a number to compare with.
             */
            get expression(): Expression;
            set expression(val: Expression);
            /**
             * Whether the sorter will sort smaller numbers first.
             */
            get sort_order(): SortType;
            set sort_order(val: SortType);
            /**
             * Whether the sorter will sort smaller numbers first.
             */
            get sortOrder(): SortType;
            set sortOrder(val: SortType);

            // Constructors

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

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

            static ['new'](expression?: Expression | null): NumericSorter;

            // Methods

            /**
             * Gets the expression that is evaluated to obtain numbers from items.
             * @returns a `GtkExpression`
             */
            get_expression(): Expression | null;
            /**
             * Gets whether this sorter will sort smaller numbers first.
             * @returns the order of the numbers
             */
            get_sort_order(): SortType;
            /**
             * Sets the expression that is evaluated to obtain numbers from items.
             *
             * Unless an expression is set on `self,` the sorter will always
             * compare items as invalid.
             *
             * The expression must have a return type that can be compared
             * numerically, such as %G_TYPE_INT or %G_TYPE_DOUBLE.
             * @param expression a `GtkExpression`
             */
            set_expression(expression?: Expression | null): void;
            /**
             * Sets whether to sort smaller numbers before larger ones.
             * @param sort_order whether to sort smaller numbers first
             */
            set_sort_order(sort_order: SortType | null): void;
        }

        /**
         * A `GObject` value in a `GtkExpression`.
         */
        class ObjectExpression extends Expression {
            static $gtype: GObject.GType<ObjectExpression>;

            // Constructors

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

            static ['new'](object: GObject.Object): ObjectExpression;

            // Methods

            /**
             * Gets the object that the expression evaluates to.
             * @returns the object, or `NULL`
             */
            get_object<T = GObject.Object>(): T;
        }

        namespace Overlay {
            // Signal callback interfaces

            interface GetChildPosition {
                (widget: Widget, allocation: Gdk.Rectangle): boolean;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                child: Widget;
            }
        }

        /**
         * `GtkOverlay` is a container which contains a single main child, on top
         * of which it can place “overlay” widgets.
         *
         * ![An example GtkOverlay](overlay.png)
         *
         * The position of each overlay widget is determined by its
         * [property`Gtk`.Widget:halign] and [property`Gtk`.Widget:valign]
         * properties. E.g. a widget with both alignments set to %GTK_ALIGN_START
         * will be placed at the top left corner of the `GtkOverlay` container,
         * whereas an overlay with halign set to %GTK_ALIGN_CENTER and valign set
         * to %GTK_ALIGN_END will be placed a the bottom edge of the `GtkOverlay`,
         * horizontally centered. The position can be adjusted by setting the margin
         * properties of the child to non-zero values.
         *
         * More complicated placement of overlays is possible by connecting
         * to the [signal`Gtk`.Overlay::get-child-position] signal.
         *
         * An overlay’s minimum and natural sizes are those of its main child.
         * The sizes of overlay children are not considered when measuring these
         * preferred sizes.
         *
         * # GtkOverlay as GtkBuildable
         *
         * The `GtkOverlay` implementation of the `GtkBuildable` interface
         * supports placing a child as an overlay by specifying “overlay” as
         * the “type” attribute of a `<child>` element.
         *
         * # CSS nodes
         *
         * `GtkOverlay` has a single CSS node with the name “overlay”. Overlay children
         * whose alignments cause them to be positioned at an edge get the style classes
         * “.left”, “.right”, “.top”, and/or “.bottom” according to their position.
         */
        class Overlay extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<Overlay>;

            // Properties

            /**
             * The main child widget.
             */
            get child(): Widget;
            set child(val: Widget);

            // Constructors

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

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

            static ['new'](): Overlay;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(
                signal: 'get-child-position',
                callback: (_source: this, widget: Widget, allocation: Gdk.Rectangle) => boolean,
            ): number;
            connect_after(
                signal: 'get-child-position',
                callback: (_source: this, widget: Widget, allocation: Gdk.Rectangle) => boolean,
            ): number;
            emit(signal: 'get-child-position', widget: Widget, allocation: Gdk.Rectangle): void;

            // Methods

            /**
             * Adds `widget` to `overlay`.
             *
             * The widget will be stacked on top of the main widget
             * added with [method`Gtk`.Overlay.set_child].
             *
             * The position at which `widget` is placed is determined
             * from its [property`Gtk`.Widget:halign] and
             * [property`Gtk`.Widget:valign] properties.
             * @param widget a `GtkWidget` to be added to the container
             */
            add_overlay(widget: Widget): void;
            /**
             * Gets the child widget of `overlay`.
             * @returns the child widget of @overlay
             */
            get_child(): Widget | null;
            /**
             * Gets whether `widget` should be clipped within the parent.
             * @param widget an overlay child of `GtkOverlay`
             * @returns whether the widget is clipped within the parent.
             */
            get_clip_overlay(widget: Widget): boolean;
            /**
             * Gets whether `widget'`s size is included in the measurement of
             * `overlay`.
             * @param widget an overlay child of `GtkOverlay`
             * @returns whether the widget is measured
             */
            get_measure_overlay(widget: Widget): boolean;
            /**
             * Removes an overlay that was added with gtk_overlay_add_overlay().
             * @param widget a `GtkWidget` to be removed
             */
            remove_overlay(widget: Widget): void;
            /**
             * Sets the child widget of `overlay`.
             * @param child the child widget
             */
            set_child(child?: Widget | null): void;
            /**
             * Sets whether `widget` should be clipped within the parent.
             * @param widget an overlay child of `GtkOverlay`
             * @param clip_overlay whether the child should be clipped
             */
            set_clip_overlay(widget: Widget, clip_overlay: boolean): void;
            /**
             * Sets whether `widget` is included in the measured size of `overlay`.
             *
             * The overlay will request the size of the largest child that has
             * this property set to %TRUE. Children who are not included may
             * be drawn outside of `overlay'`s allocation if they are too large.
             * @param widget an overlay child of `GtkOverlay`
             * @param measure whether the child should be measured
             */
            set_measure_overlay(widget: Widget, measure: boolean): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace OverlayLayout {
            // Constructor properties interface

            interface ConstructorProps extends LayoutManager.ConstructorProps {}
        }

        /**
         * `GtkOverlayLayout` is the layout manager used by [class`Gtk`.Overlay].
         *
         * It places widgets as overlays on top of the main child.
         *
         * This is not a reusable layout manager, since it expects its widget
         * to be a `GtkOverlay`. It is only listed here so that its layout
         * properties get documented.
         */
        class OverlayLayout extends LayoutManager {
            static $gtype: GObject.GType<OverlayLayout>;

            // Constructors

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

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

            static ['new'](): OverlayLayout;
        }

        namespace OverlayLayoutChild {
            // Constructor properties interface

            interface ConstructorProps extends LayoutChild.ConstructorProps {
                clip_overlay: boolean;
                clipOverlay: boolean;
                measure: boolean;
            }
        }

        /**
         * `GtkLayoutChild` subclass for children in a `GtkOverlayLayout`.
         */
        class OverlayLayoutChild extends LayoutChild {
            static $gtype: GObject.GType<OverlayLayoutChild>;

            // Properties

            /**
             * Whether the child should be clipped to fit the parent's size.
             */
            get clip_overlay(): boolean;
            set clip_overlay(val: boolean);
            /**
             * Whether the child should be clipped to fit the parent's size.
             */
            get clipOverlay(): boolean;
            set clipOverlay(val: boolean);
            /**
             * Whether the child size should contribute to the `GtkOverlayLayout`'s
             * measurement.
             */
            get measure(): boolean;
            set measure(val: boolean);

            // Constructors

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

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

            // Methods

            /**
             * Retrieves whether the child is clipped.
             * @returns whether the child is clipped
             */
            get_clip_overlay(): boolean;
            /**
             * Retrieves whether the child is measured.
             * @returns whether the child is measured
             */
            get_measure(): boolean;
            /**
             * Sets whether to clip this child.
             * @param clip_overlay whether to clip this child
             */
            set_clip_overlay(clip_overlay: boolean): void;
            /**
             * Sets whether to measure this child.
             * @param measure whether to measure this child
             */
            set_measure(measure: boolean): void;
        }

        namespace PadController {
            // Constructor properties interface

            interface ConstructorProps extends EventController.ConstructorProps {
                action_group: Gio.ActionGroup;
                actionGroup: Gio.ActionGroup;
                pad: Gdk.Device;
            }
        }

        /**
         * `GtkPadController` is an event controller for the pads found in drawing
         * tablets.
         *
         * Pads are the collection of buttons and tactile sensors often found around
         * the stylus-sensitive area.
         *
         * These buttons and sensors have no implicit meaning, and by default they
         * perform no action. `GtkPadController` is provided to map those to
         * [iface`Gio`.Action] objects, thus letting the application give them a more
         * semantic meaning.
         *
         * Buttons and sensors are not constrained to triggering a single action,
         * some %GDK_SOURCE_TABLET_PAD devices feature multiple "modes". All these
         * input elements have one current mode, which may determine the final action
         * being triggered.
         *
         * Pad devices often divide buttons and sensors into groups. All elements
         * in a group share the same current mode, but different groups may have
         * different modes. See [method`Gdk`.DevicePad.get_n_groups] and
         * [method`Gdk`.DevicePad.get_group_n_modes].
         *
         * Each of the actions that a given button/strip/ring performs for a given mode
         * is defined by a [struct`Gtk`.PadActionEntry]. It contains an action name that
         * will be looked up in the given [iface`Gio`.ActionGroup] and activated whenever
         * the specified input element and mode are triggered.
         *
         * A simple example of `GtkPadController` usage: Assigning button 1 in all
         * modes and pad devices to an "invert-selection" action:
         *
         * ```c
         * GtkPadActionEntry *pad_actions[] = {
         *   { GTK_PAD_ACTION_BUTTON, 1, -1, "Invert selection", "pad-actions.invert-selection" },
         *   …
         * };
         *
         * …
         * action_group = g_simple_action_group_new ();
         * action = g_simple_action_new ("pad-actions.invert-selection", NULL);
         * g_signal_connect (action, "activate", on_invert_selection_activated, NULL);
         * g_action_map_add_action (G_ACTION_MAP (action_group), action);
         * …
         * pad_controller = gtk_pad_controller_new (action_group, NULL);
         * ```
         *
         * The actions belonging to rings/strips will be activated with a parameter
         * of type %G_VARIANT_TYPE_DOUBLE bearing the value of the given axis, it
         * is required that those are made stateful and accepting this `GVariantType`.
         */
        class PadController extends EventController {
            static $gtype: GObject.GType<PadController>;

            // Properties

            /**
             * The action group of the controller.
             */
            get action_group(): Gio.ActionGroup;
            /**
             * The action group of the controller.
             */
            get actionGroup(): Gio.ActionGroup;
            /**
             * The pad of the controller.
             */
            get pad(): Gdk.Device;

            // Constructors

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

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

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

            // Methods

            /**
             * Adds an individual action to `controller`.
             *
             * This action will only be activated if the given button/ring/strip number
             * in `index` is interacted while the current mode is `mode`. -1 may be used
             * for simple cases, so the action is triggered on all modes.
             *
             * The given `label` should be considered user-visible, so internationalization
             * rules apply. Some windowing systems may be able to use those for user
             * feedback.
             * @param type the type of pad feature that will trigger this action
             * @param index the 0-indexed button/ring/strip number that will trigger this action
             * @param mode the mode that will trigger this action, or -1 for all modes.
             * @param label Human readable description of this action, this string should   be deemed user-visible.
             * @param action_name action name that will be activated in the `GActionGroup`
             */
            set_action(
                type: PadActionType | null,
                index: number,
                mode: number,
                label: string,
                action_name: string,
            ): void;
            /**
             * A convenience function to add a group of action entries on
             * `controller`.
             *
             * See [struct`Gtk`.PadActionEntry] and [method`Gtk`.PadController.set_action].
             * @param entries the action entries to set on @controller
             */
            set_action_entries(entries: PadActionEntry[]): void;
        }

        namespace PageSetup {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * A `GtkPageSetup` object stores the page size, orientation and margins.
         *
         * The idea is that you can get one of these from the page setup dialog
         * and then pass it to the `GtkPrintOperation` when printing.
         * The benefit of splitting this out of the `GtkPrintSettings` is that
         * these affect the actual layout of the page, and thus need to be set
         * long before user prints.
         *
         * ## Margins
         *
         * The margins specified in this object are the “print margins”, i.e. the
         * parts of the page that the printer cannot print on. These are different
         * from the layout margins that a word processor uses; they are typically
         * used to determine the minimal size for the layout margins.
         *
         * To obtain a `GtkPageSetup` use [ctor`Gtk`.PageSetup.new] to get the defaults,
         * or use [func`Gtk`.print_run_page_setup_dialog] to show the page setup dialog
         * and receive the resulting page setup.
         *
         * ## A page setup dialog
         *
         * ```c
         * static GtkPrintSettings *settings = NULL;
         * static GtkPageSetup *page_setup = NULL;
         *
         * static void
         * do_page_setup (void)
         * {
         *   GtkPageSetup *new_page_setup;
         *
         *   if (settings == NULL)
         *     settings = gtk_print_settings_new ();
         *
         *   new_page_setup = gtk_print_run_page_setup_dialog (GTK_WINDOW (main_window),
         *                                                     page_setup, settings);
         *
         *   if (page_setup)
         *     g_object_unref (page_setup);
         *
         *   page_setup = new_page_setup;
         * }
         * ```
         */
        class PageSetup extends GObject.Object {
            static $gtype: GObject.GType<PageSetup>;

            // Constructors

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

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

            static ['new'](): PageSetup;

            static new_from_file(file_name: string): PageSetup;

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

            static new_from_key_file(key_file: GLib.KeyFile, group_name?: string | null): PageSetup;

            // Methods

            /**
             * Copies a `GtkPageSetup`.
             * @returns a copy of @other
             */
            copy(): PageSetup;
            /**
             * Gets the bottom margin in units of `unit`.
             * @param unit the unit for the return value
             * @returns the bottom margin
             */
            get_bottom_margin(unit: Unit | null): number;
            /**
             * Gets the left margin in units of `unit`.
             * @param unit the unit for the return value
             * @returns the left margin
             */
            get_left_margin(unit: Unit | null): number;
            /**
             * Gets the page orientation of the `GtkPageSetup`.
             * @returns the page orientation
             */
            get_orientation(): PageOrientation;
            /**
             * Returns the page height in units of `unit`.
             *
             * Note that this function takes orientation
             * and margins into consideration.
             * See [method`Gtk`.PageSetup.get_paper_height].
             * @param unit the unit for the return value
             * @returns the page height.
             */
            get_page_height(unit: Unit | null): number;
            /**
             * Returns the page width in units of `unit`.
             *
             * Note that this function takes orientation
             * and margins into consideration.
             * See [method`Gtk`.PageSetup.get_paper_width].
             * @param unit the unit for the return value
             * @returns the page width.
             */
            get_page_width(unit: Unit | null): number;
            /**
             * Returns the paper height in units of `unit`.
             *
             * Note that this function takes orientation,
             * but not margins into consideration.
             * See [method`Gtk`.PageSetup.get_page_height].
             * @param unit the unit for the return value
             * @returns the paper height.
             */
            get_paper_height(unit: Unit | null): number;
            /**
             * Gets the paper size of the `GtkPageSetup`.
             * @returns the paper size
             */
            get_paper_size(): PaperSize;
            /**
             * Returns the paper width in units of `unit`.
             *
             * Note that this function takes orientation,
             * but not margins into consideration.
             * See [method`Gtk`.PageSetup.get_page_width].
             * @param unit the unit for the return value
             * @returns the paper width.
             */
            get_paper_width(unit: Unit | null): number;
            /**
             * Gets the right margin in units of `unit`.
             * @param unit the unit for the return value
             * @returns the right margin
             */
            get_right_margin(unit: Unit | null): number;
            /**
             * Gets the top margin in units of `unit`.
             * @param unit the unit for the return value
             * @returns the top margin
             */
            get_top_margin(unit: Unit | null): number;
            /**
             * Reads the page setup from the file `file_name`.
             *
             * See [method`Gtk`.PageSetup.to_file].
             * @param file_name the filename to read the page setup from
             * @returns %TRUE on success
             */
            load_file(file_name: string): boolean;
            /**
             * Reads the page setup from the group `group_name` in the key file
             * `key_file`.
             * @param key_file the `GKeyFile` to retrieve the page_setup from
             * @param group_name the name of the group in the key_file to read   to use the default name “Page Setup”
             * @returns %TRUE on success
             */
            load_key_file(key_file: GLib.KeyFile, group_name?: string | null): boolean;
            /**
             * Sets the bottom margin of the `GtkPageSetup`.
             * @param margin the new bottom margin in units of @unit
             * @param unit the units for @margin
             */
            set_bottom_margin(margin: number, unit: Unit | null): void;
            /**
             * Sets the left margin of the `GtkPageSetup`.
             * @param margin the new left margin in units of @unit
             * @param unit the units for @margin
             */
            set_left_margin(margin: number, unit: Unit | null): void;
            /**
             * Sets the page orientation of the `GtkPageSetup`.
             * @param orientation a `GtkPageOrientation` value
             */
            set_orientation(orientation: PageOrientation | null): void;
            /**
             * Sets the paper size of the `GtkPageSetup` without
             * changing the margins.
             *
             * See [method`Gtk`.PageSetup.set_paper_size_and_default_margins].
             * @param size a `GtkPaperSize`
             */
            set_paper_size(size: PaperSize): void;
            /**
             * Sets the paper size of the `GtkPageSetup` and modifies
             * the margins according to the new paper size.
             * @param size a `GtkPaperSize`
             */
            set_paper_size_and_default_margins(size: PaperSize): void;
            /**
             * Sets the right margin of the `GtkPageSetup`.
             * @param margin the new right margin in units of @unit
             * @param unit the units for @margin
             */
            set_right_margin(margin: number, unit: Unit | null): void;
            /**
             * Sets the top margin of the `GtkPageSetup`.
             * @param margin the new top margin in units of @unit
             * @param unit the units for @margin
             */
            set_top_margin(margin: number, unit: Unit | null): void;
            /**
             * This function saves the information from `setup` to `file_name`.
             * @param file_name the file to save to
             * @returns %TRUE on success
             */
            to_file(file_name: string): boolean;
            /**
             * Serialize page setup to an a{sv} variant.
             * @returns a new, floating, `GVariant`
             */
            to_gvariant(): GLib.Variant;
            /**
             * This function adds the page setup from `setup` to `key_file`.
             * @param key_file the `GKeyFile` to save the page setup to
             * @param group_name the group to add the settings to in @key_file,   or %NULL to use the default name “Page Setup”
             */
            to_key_file(key_file: GLib.KeyFile, group_name?: string | null): void;
        }

        namespace PageSetupUnixDialog {
            // Constructor properties interface

            interface ConstructorProps
                extends Dialog.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Native.ConstructorProps,
                    Root.ConstructorProps,
                    ShortcutManager.ConstructorProps {}
        }

        /**
         * `GtkPageSetupUnixDialog` implements a page setup dialog for platforms
         * which don’t provide a native page setup dialog, like Unix.
         *
         * ![An example GtkPageSetupUnixDialog](pagesetupdialog.png)
         *
         * It can be used very much like any other GTK dialog, at the
         * cost of the portability offered by the high-level printing
         * API in [class`Gtk`.PrintOperation].
         *
         * ## CSS nodes
         *
         * `GtkPageSetupUnixDialog` has a single CSS node with the name `window` and
         * style class `.pagesetup`.
         */
        class PageSetupUnixDialog
            extends Dialog
            implements Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager
        {
            static $gtype: GObject.GType<PageSetupUnixDialog>;

            // Constructors

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

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

            static ['new'](title?: string | null, parent?: Window | null): PageSetupUnixDialog;
            // Conflicted with Gtk.Dialog.new

            static ['new'](...args: never[]): any;

            // Methods

            /**
             * Gets the currently selected page setup from the dialog.
             * @returns the current page setup
             */
            get_page_setup(): PageSetup;
            /**
             * Gets the current print settings from the dialog.
             * @returns the current print settings
             */
            get_print_settings(): PrintSettings | null;
            /**
             * Sets the `GtkPageSetup` from which the page setup
             * dialog takes its values.
             * @param page_setup a `GtkPageSetup`
             */
            set_page_setup(page_setup: PageSetup): void;
            /**
             * Sets the `GtkPrintSettings` from which the page setup dialog
             * takes its values.
             * @param print_settings a `GtkPrintSettings`
             */
            set_print_settings(print_settings?: PrintSettings | null): void;

            // Inherited properties
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace Paned {
            // Signal callback interfaces

            interface AcceptPosition {
                (): boolean;
            }

            interface CancelPosition {
                (): boolean;
            }

            interface CycleChildFocus {
                (reversed: boolean): boolean;
            }

            interface CycleHandleFocus {
                (reversed: boolean): boolean;
            }

            interface MoveHandle {
                (scroll_type: ScrollType): boolean;
            }

            interface ToggleHandleFocus {
                (): boolean;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    AccessibleRange.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Orientable.ConstructorProps {
                end_child: Widget;
                endChild: Widget;
                max_position: number;
                maxPosition: number;
                min_position: number;
                minPosition: number;
                position: number;
                position_set: boolean;
                positionSet: boolean;
                resize_end_child: boolean;
                resizeEndChild: boolean;
                resize_start_child: boolean;
                resizeStartChild: boolean;
                shrink_end_child: boolean;
                shrinkEndChild: boolean;
                shrink_start_child: boolean;
                shrinkStartChild: boolean;
                start_child: Widget;
                startChild: Widget;
                wide_handle: boolean;
                wideHandle: boolean;
            }
        }

        /**
         * A widget with two panes, arranged either horizontally or vertically.
         *
         * ![An example GtkPaned](panes.png)
         *
         * The division between the two panes is adjustable by the user
         * by dragging a handle.
         *
         * Child widgets are added to the panes of the widget with
         * [method`Gtk`.Paned.set_start_child] and [method`Gtk`.Paned.set_end_child].
         * The division between the two children is set by default from the size
         * requests of the children, but it can be adjusted by the user.
         *
         * A paned widget draws a separator between the two child widgets and a
         * small handle that the user can drag to adjust the division. It does not
         * draw any relief around the children or around the separator. (The space
         * in which the separator is called the gutter.) Often, it is useful to put
         * each child inside a [class`Gtk`.Frame] so that the gutter appears as a
         * ridge. No separator is drawn if one of the children is missing.
         *
         * Each child has two options that can be set, "resize" and "shrink". If
         * "resize" is true then, when the `GtkPaned` is resized, that child will
         * expand or shrink along with the paned widget. If "shrink" is true, then
         * that child can be made smaller than its requisition by the user.
         * Setting "shrink" to false allows the application to set a minimum size.
         * If "resize" is false for both children, then this is treated as if
         * "resize" is true for both children.
         *
         * The application can set the position of the slider as if it were set
         * by the user, by calling [method`Gtk`.Paned.set_position].
         *
         * # Shortcuts and Gestures
         *
         * The following signals have default keybindings:
         *
         * - [signal`Gtk`.Paned::accept-position]
         * - [signal`Gtk`.Paned::cancel-position]
         * - [signal`Gtk`.Paned::cycle-child-focus]
         * - [signal`Gtk`.Paned::cycle-handle-focus]
         * - [signal`Gtk`.Paned::move-handle]
         * - [signal`Gtk`.Paned::toggle-handle-focus]
         *
         * # CSS nodes
         *
         * ```
         * paned
         * ├── <child>
         * ├── separator[.wide]
         * ╰── <child>
         * ```
         *
         * `GtkPaned` has a main CSS node with name paned, and a subnode for
         * the separator with name separator. The subnode gets a .wide style
         * class when the paned is supposed to be wide.
         *
         * In horizontal orientation, the nodes are arranged based on the text
         * direction, so in left-to-right mode, :first-child will select the
         * leftmost child, while it will select the rightmost child in
         * RTL layouts.
         *
         * ## Creating a paned widget with minimum sizes.
         *
         * ```c
         * GtkWidget *hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
         * GtkWidget *frame1 = gtk_frame_new (NULL);
         * GtkWidget *frame2 = gtk_frame_new (NULL);
         *
         * gtk_widget_set_size_request (hpaned, 200, -1);
         *
         * gtk_paned_set_start_child (GTK_PANED (hpaned), frame1);
         * gtk_paned_set_resize_start_child (GTK_PANED (hpaned), TRUE);
         * gtk_paned_set_shrink_start_child (GTK_PANED (hpaned), FALSE);
         * gtk_widget_set_size_request (frame1, 50, -1);
         *
         * gtk_paned_set_end_child (GTK_PANED (hpaned), frame2);
         * gtk_paned_set_resize_end_child (GTK_PANED (hpaned), FALSE);
         * gtk_paned_set_shrink_end_child (GTK_PANED (hpaned), FALSE);
         * gtk_widget_set_size_request (frame2, 50, -1);
         * ```
         */
        class Paned extends Widget implements Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable {
            static $gtype: GObject.GType<Paned>;

            // Properties

            /**
             * The second child.
             */
            get end_child(): Widget;
            set end_child(val: Widget);
            /**
             * The second child.
             */
            get endChild(): Widget;
            set endChild(val: Widget);
            /**
             * The largest possible value for the [property`Gtk`.Paned:position]
             * property.
             *
             * This property is derived from the size and shrinkability
             * of the widget's children.
             */
            get max_position(): number;
            /**
             * The largest possible value for the [property`Gtk`.Paned:position]
             * property.
             *
             * This property is derived from the size and shrinkability
             * of the widget's children.
             */
            get maxPosition(): number;
            /**
             * The smallest possible value for the [property`Gtk`.Paned:position]
             * property.
             *
             * This property is derived from the size and shrinkability
             * of the widget's children.
             */
            get min_position(): number;
            /**
             * The smallest possible value for the [property`Gtk`.Paned:position]
             * property.
             *
             * This property is derived from the size and shrinkability
             * of the widget's children.
             */
            get minPosition(): number;
            /**
             * Position of the separator in pixels, from the left/top.
             */
            get position(): number;
            set position(val: number);
            /**
             * Whether the [property`Gtk`.Paned:position] property has been set.
             */
            get position_set(): boolean;
            set position_set(val: boolean);
            /**
             * Whether the [property`Gtk`.Paned:position] property has been set.
             */
            get positionSet(): boolean;
            set positionSet(val: boolean);
            /**
             * Determines whether the second child expands and shrinks
             * along with the paned widget.
             */
            get resize_end_child(): boolean;
            set resize_end_child(val: boolean);
            /**
             * Determines whether the second child expands and shrinks
             * along with the paned widget.
             */
            get resizeEndChild(): boolean;
            set resizeEndChild(val: boolean);
            /**
             * Determines whether the first child expands and shrinks
             * along with the paned widget.
             */
            get resize_start_child(): boolean;
            set resize_start_child(val: boolean);
            /**
             * Determines whether the first child expands and shrinks
             * along with the paned widget.
             */
            get resizeStartChild(): boolean;
            set resizeStartChild(val: boolean);
            /**
             * Determines whether the second child can be made smaller
             * than its requisition.
             */
            get shrink_end_child(): boolean;
            set shrink_end_child(val: boolean);
            /**
             * Determines whether the second child can be made smaller
             * than its requisition.
             */
            get shrinkEndChild(): boolean;
            set shrinkEndChild(val: boolean);
            /**
             * Determines whether the first child can be made smaller
             * than its requisition.
             */
            get shrink_start_child(): boolean;
            set shrink_start_child(val: boolean);
            /**
             * Determines whether the first child can be made smaller
             * than its requisition.
             */
            get shrinkStartChild(): boolean;
            set shrinkStartChild(val: boolean);
            /**
             * The first child.
             */
            get start_child(): Widget;
            set start_child(val: Widget);
            /**
             * The first child.
             */
            get startChild(): Widget;
            set startChild(val: Widget);
            /**
             * Whether the `GtkPaned` should provide a stronger visual separation.
             *
             * For example, this could be set when a paned contains two
             * [class`Gtk`.Notebook]s, whose tab rows would otherwise merge visually.
             */
            get wide_handle(): boolean;
            set wide_handle(val: boolean);
            /**
             * Whether the `GtkPaned` should provide a stronger visual separation.
             *
             * For example, this could be set when a paned contains two
             * [class`Gtk`.Notebook]s, whose tab rows would otherwise merge visually.
             */
            get wideHandle(): boolean;
            set wideHandle(val: boolean);

            // Constructors

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

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

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

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'accept-position', callback: (_source: this) => boolean): number;
            connect_after(signal: 'accept-position', callback: (_source: this) => boolean): number;
            emit(signal: 'accept-position'): void;
            connect(signal: 'cancel-position', callback: (_source: this) => boolean): number;
            connect_after(signal: 'cancel-position', callback: (_source: this) => boolean): number;
            emit(signal: 'cancel-position'): void;
            connect(signal: 'cycle-child-focus', callback: (_source: this, reversed: boolean) => boolean): number;
            connect_after(signal: 'cycle-child-focus', callback: (_source: this, reversed: boolean) => boolean): number;
            emit(signal: 'cycle-child-focus', reversed: boolean): void;
            connect(signal: 'cycle-handle-focus', callback: (_source: this, reversed: boolean) => boolean): number;
            connect_after(
                signal: 'cycle-handle-focus',
                callback: (_source: this, reversed: boolean) => boolean,
            ): number;
            emit(signal: 'cycle-handle-focus', reversed: boolean): void;
            connect(signal: 'move-handle', callback: (_source: this, scroll_type: ScrollType) => boolean): number;
            connect_after(signal: 'move-handle', callback: (_source: this, scroll_type: ScrollType) => boolean): number;
            emit(signal: 'move-handle', scroll_type: ScrollType): void;
            connect(signal: 'toggle-handle-focus', callback: (_source: this) => boolean): number;
            connect_after(signal: 'toggle-handle-focus', callback: (_source: this) => boolean): number;
            emit(signal: 'toggle-handle-focus'): void;

            // Methods

            /**
             * Retrieves the end child of the given `GtkPaned`.
             * @returns the end child widget
             */
            get_end_child(): Widget | null;
            /**
             * Obtains the position of the divider between the two panes.
             * @returns the position of the divider, in pixels
             */
            get_position(): number;
            /**
             * Returns whether the [property`Gtk`.Paned:end-child] can be resized.
             * @returns true if the end child is resizable
             */
            get_resize_end_child(): boolean;
            /**
             * Returns whether the [property`Gtk`.Paned:start-child] can be resized.
             * @returns true if the start child is resizable
             */
            get_resize_start_child(): boolean;
            /**
             * Returns whether the [property`Gtk`.Paned:end-child] can shrink.
             * @returns true if the end child is shrinkable
             */
            get_shrink_end_child(): boolean;
            /**
             * Returns whether the [property`Gtk`.Paned:start-child] can shrink.
             * @returns true if the start child is shrinkable
             */
            get_shrink_start_child(): boolean;
            /**
             * Retrieves the start child of the given `GtkPaned`.
             * @returns the start child widget
             */
            get_start_child(): Widget | null;
            /**
             * Gets whether the separator should be wide.
             * @returns %TRUE if the paned should have a wide handle
             */
            get_wide_handle(): boolean;
            /**
             * Sets the end child of `paned` to `child`.
             *
             * If `child` is `NULL`, the existing child will be removed.
             * @param child the widget to add
             */
            set_end_child(child?: Widget | null): void;
            /**
             * Sets the position of the divider between the two panes.
             * @param position pixel position of divider, a negative value means that the position   is unset
             */
            set_position(position: number): void;
            /**
             * Sets whether the [property`Gtk`.Paned:end-child] can be resized.
             * @param resize true to let the end child be resized
             */
            set_resize_end_child(resize: boolean): void;
            /**
             * Sets whether the [property`Gtk`.Paned:start-child] can be resized.
             * @param resize true to let the start child be resized
             */
            set_resize_start_child(resize: boolean): void;
            /**
             * Sets whether the [property`Gtk`.Paned:end-child] can shrink.
             * @param resize true to let the end child be shrunk
             */
            set_shrink_end_child(resize: boolean): void;
            /**
             * Sets whether the [property`Gtk`.Paned:start-child] can shrink.
             * @param resize true to let the start child be shrunk
             */
            set_shrink_start_child(resize: boolean): void;
            /**
             * Sets the start child of `paned` to `child`.
             *
             * If `child` is `NULL`, the existing child will be removed.
             * @param child the widget to add
             */
            set_start_child(child?: Widget | null): void;
            /**
             * Sets whether the separator should be wide.
             * @param wide the new value for the [property@Gtk.Paned:wide-handle] property
             */
            set_wide_handle(wide: boolean): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Sets the current value of the accessible range.
             *
             * This operation should behave similarly as if the user performed the
             * action.
             * @param value the value to set
             */
            vfunc_set_current_value(value: number): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace PasswordEntry {
            // Signal callback interfaces

            interface Activate {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Editable.ConstructorProps {
                activates_default: boolean;
                activatesDefault: boolean;
                extra_menu: Gio.MenuModel;
                extraMenu: Gio.MenuModel;
                placeholder_text: string;
                placeholderText: string;
                show_peek_icon: boolean;
                showPeekIcon: boolean;
            }
        }

        /**
         * `GtkPasswordEntry` is an entry that has been tailored for entering secrets.
         *
         * ![An example GtkPasswordEntry](password-entry.png)
         *
         * It does not show its contents in clear text, does not allow to copy it
         * to the clipboard, and it shows a warning when Caps Lock is engaged. If
         * the underlying platform allows it, `GtkPasswordEntry` will also place
         * the text in a non-pageable memory area, to avoid it being written out
         * to disk by the operating system.
         *
         * Optionally, it can offer a way to reveal the contents in clear text.
         *
         * `GtkPasswordEntry` provides only minimal API and should be used with
         * the [iface`Gtk`.Editable] API.
         *
         * # CSS Nodes
         *
         * ```
         * entry.password
         * ╰── text
         *     ├── image.caps-lock-indicator
         *     ┊
         * ```
         *
         * `GtkPasswordEntry` has a single CSS node with name entry that carries
         * a .passwordstyle class. The text Css node below it has a child with
         * name image and style class .caps-lock-indicator for the Caps Lock
         * icon, and possibly other children.
         *
         * # Accessibility
         *
         * `GtkPasswordEntry` uses the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role.
         */
        class PasswordEntry extends Widget implements Accessible, Buildable, ConstraintTarget, Editable {
            static $gtype: GObject.GType<PasswordEntry>;

            // Properties

            /**
             * Whether to activate the default widget when Enter is pressed.
             */
            get activates_default(): boolean;
            set activates_default(val: boolean);
            /**
             * Whether to activate the default widget when Enter is pressed.
             */
            get activatesDefault(): boolean;
            set activatesDefault(val: boolean);
            /**
             * A menu model whose contents will be appended to
             * the context menu.
             */
            get extra_menu(): Gio.MenuModel;
            set extra_menu(val: Gio.MenuModel);
            /**
             * A menu model whose contents will be appended to
             * the context menu.
             */
            get extraMenu(): Gio.MenuModel;
            set extraMenu(val: Gio.MenuModel);
            /**
             * The text that will be displayed in the `GtkPasswordEntry`
             * when it is empty and unfocused.
             */
            get placeholder_text(): string;
            set placeholder_text(val: string);
            /**
             * The text that will be displayed in the `GtkPasswordEntry`
             * when it is empty and unfocused.
             */
            get placeholderText(): string;
            set placeholderText(val: string);
            /**
             * Whether to show an icon for revealing the content.
             */
            get show_peek_icon(): boolean;
            set show_peek_icon(val: boolean);
            /**
             * Whether to show an icon for revealing the content.
             */
            get showPeekIcon(): boolean;
            set showPeekIcon(val: boolean);

            // Constructors

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

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

            static ['new'](): PasswordEntry;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate', callback: (_source: this) => void): number;
            connect_after(signal: 'activate', callback: (_source: this) => void): number;
            emit(signal: 'activate'): void;

            // Methods

            /**
             * Gets the menu model set with gtk_password_entry_set_extra_menu().
             * @returns the menu model
             */
            get_extra_menu(): Gio.MenuModel | null;
            /**
             * Returns whether the entry is showing an icon to
             * reveal the contents.
             * @returns %TRUE if an icon is shown
             */
            get_show_peek_icon(): boolean;
            /**
             * Sets a menu model to add when constructing
             * the context menu for `entry`.
             * @param model a `GMenuModel`
             */
            set_extra_menu(model?: Gio.MenuModel | null): void;
            /**
             * Sets whether the entry should have a clickable icon
             * to reveal the contents.
             *
             * Setting this to %FALSE also hides the text again.
             * @param show_peek_icon whether to show the peek icon
             */
            set_show_peek_icon(show_peek_icon: boolean): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The current position of the insertion cursor in chars.
             */
            get cursor_position(): number;
            /**
             * The current position of the insertion cursor in chars.
             */
            get cursorPosition(): number;
            /**
             * Whether the entry contents can be edited.
             */
            get editable(): boolean;
            set editable(val: boolean);
            /**
             * If undo/redo should be enabled for the editable.
             */
            get enable_undo(): boolean;
            set enable_undo(val: boolean);
            /**
             * If undo/redo should be enabled for the editable.
             */
            get enableUndo(): boolean;
            set enableUndo(val: boolean);
            /**
             * The desired maximum width of the entry, in characters.
             */
            get max_width_chars(): number;
            set max_width_chars(val: number);
            /**
             * The desired maximum width of the entry, in characters.
             */
            get maxWidthChars(): number;
            set maxWidthChars(val: number);
            /**
             * The position of the opposite end of the selection from the cursor in chars.
             */
            get selection_bound(): number;
            /**
             * The position of the opposite end of the selection from the cursor in chars.
             */
            get selectionBound(): number;
            /**
             * The contents of the entry.
             */
            get text(): string;
            set text(val: string);
            /**
             * Number of characters to leave space for in the entry.
             */
            get width_chars(): number;
            set width_chars(val: number);
            /**
             * Number of characters to leave space for in the entry.
             */
            get widthChars(): number;
            set widthChars(val: number);
            /**
             * The horizontal alignment, from 0 (left) to 1 (right).
             *
             * Reversed for RTL layouts.
             */
            get xalign(): number;
            set xalign(val: number);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Retrieves the accessible platform state from the editable delegate.
             *
             * This is an helper function to retrieve the accessible state for
             * `GtkEditable` interface implementations using a delegate pattern.
             *
             * You should call this function in your editable widget implementation
             * of the [vfunc`Gtk`.Accessible.get_platform_state] virtual function, for
             * instance:
             *
             * ```c
             * static void
             * accessible_interface_init (GtkAccessibleInterface *iface)
             * {
             *   iface->get_platform_state = your_editable_get_accessible_platform_state;
             * }
             *
             * static gboolean
             * your_editable_get_accessible_platform_state (GtkAccessible *accessible,
             *                                              GtkAccessiblePlatformState state)
             * {
             *   return gtk_editable_delegate_get_accessible_platform_state (GTK_EDITABLE (accessible), state);
             * }
             * ```
             *
             * Note that the widget which is the delegate *must* be a direct child of
             * this widget, otherwise your implementation of [vfunc`Gtk`.Accessible.get_platform_state]
             * might not even be called, as the platform change will originate from
             * the parent of the delegate, and, as a result, will not work properly.
             *
             * So, if you can't ensure the direct child condition, you should give the
             * delegate the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role, or you can
             * change your tree to allow this function to work.
             * @param state what kind of accessible state to retrieve
             * @returns the accessible platform state of the delegate
             */
            delegate_get_accessible_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Deletes the currently selected text of the editable.
             *
             * This call doesn’t do anything if there is no selected text.
             */
            delete_selection(): void;
            /**
             * Deletes a sequence of characters.
             *
             * The characters that are deleted are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters deleted are those from `start_pos` to
             * the end of the text.
             *
             * Note that the positions are specified in characters, not bytes.
             * @param start_pos start position
             * @param end_pos end position
             */
            delete_text(start_pos: number, end_pos: number): void;
            /**
             * Undoes the setup done by [method`Gtk`.Editable.init_delegate].
             *
             * This is a helper function that should be called from dispose,
             * before removing the delegate object.
             */
            finish_delegate(): void;
            /**
             * Gets the alignment of the editable.
             * @returns the alignment
             */
            get_alignment(): number;
            /**
             * Retrieves a sequence of characters.
             *
             * The characters that are retrieved are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is negative,
             * then the characters retrieved are those characters from `start_pos` to
             * the end of the text.
             *
             * Note that positions are specified in characters, not bytes.
             * @param start_pos start of text
             * @param end_pos end of text
             * @returns a pointer to the contents of the widget as a   string. This string is allocated by the `GtkEditable` implementation   and should be freed by the caller.
             */
            get_chars(start_pos: number, end_pos: number): string;
            /**
             * Gets the `GtkEditable` that `editable` is delegating its
             * implementation to.
             *
             * Typically, the delegate is a [class`Gtk`.Text] widget.
             * @returns the delegate `GtkEditable`
             */
            get_delegate(): Editable | null;
            /**
             * Retrieves whether `editable` is editable.
             * @returns %TRUE if @editable is editable.
             */
            get_editable(): boolean;
            /**
             * Gets if undo/redo actions are enabled for `editable`
             * @returns %TRUE if undo is enabled
             */
            get_enable_undo(): boolean;
            /**
             * Retrieves the desired maximum width of `editable,` in characters.
             * @returns the maximum width of the entry, in characters
             */
            get_max_width_chars(): number;
            /**
             * Retrieves the current position of the cursor relative
             * to the start of the content of the editable.
             *
             * Note that this position is in characters, not in bytes.
             * @returns the cursor position
             */
            get_position(): number;
            /**
             * Retrieves the selection bound of the editable.
             *
             * `start_pos` will be filled with the start of the selection and
             * `end_pos` with end. If no text was selected both will be identical
             * and %FALSE will be returned.
             *
             * Note that positions are specified in characters, not bytes.
             * @returns %TRUE if there is a non-empty selection, %FALSE otherwise
             */
            get_selection_bounds(): [boolean, number, number];
            /**
             * Retrieves the contents of `editable`.
             *
             * The returned string is owned by GTK and must not be modified or freed.
             * @returns a pointer to the contents of the editable
             */
            get_text(): string;
            /**
             * Gets the number of characters of space reserved
             * for the contents of the editable.
             * @returns number of chars to request space for, or negative if unset
             */
            get_width_chars(): number;
            /**
             * Sets up a delegate for `GtkEditable`.
             *
             * This is assuming that the get_delegate vfunc in the `GtkEditable`
             * interface has been set up for the `editable'`s type.
             *
             * This is a helper function that should be called in instance init,
             * after creating the delegate object.
             */
            init_delegate(): void;
            /**
             * Inserts `length` bytes of `text` into the contents of the
             * widget, at position `position`.
             *
             * Note that the position is in characters, not in bytes.
             * The function updates `position` to point after the newly
             * inserted text.
             * @param text the text to insert
             * @param length the length of the text in bytes, or -1
             * @param position location of the position text will be inserted at
             */
            insert_text(text: string, length: number, position: number): number;
            /**
             * Selects a region of text.
             *
             * The characters that are selected are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters selected are those characters from
             * `start_pos` to  the end of the text.
             *
             * Note that positions are specified in characters, not bytes.
             * @param start_pos start of region
             * @param end_pos end of region
             */
            select_region(start_pos: number, end_pos: number): void;
            /**
             * Sets the alignment for the contents of the editable.
             *
             * This controls the horizontal positioning of the contents when
             * the displayed text is shorter than the width of the editable.
             * @param xalign The horizontal alignment, from 0 (left) to 1 (right).   Reversed for RTL layouts
             */
            set_alignment(xalign: number): void;
            /**
             * Determines if the user can edit the text in the editable widget.
             * @param is_editable %TRUE if the user is allowed to edit the text   in the widget
             */
            set_editable(is_editable: boolean): void;
            /**
             * If enabled, changes to `editable` will be saved for undo/redo
             * actions.
             *
             * This results in an additional copy of text changes and are not
             * stored in secure memory. As such, undo is forcefully disabled
             * when [property`Gtk`.Text:visibility] is set to %FALSE.
             * @param enable_undo if undo/redo should be enabled
             */
            set_enable_undo(enable_undo: boolean): void;
            /**
             * Sets the desired maximum width in characters of `editable`.
             * @param n_chars the new desired maximum width, in characters
             */
            set_max_width_chars(n_chars: number): void;
            /**
             * Sets the cursor position in the editable to the given value.
             *
             * The cursor is displayed before the character with the given (base 0)
             * index in the contents of the editable. The value must be less than
             * or equal to the number of characters in the editable. A value of -1
             * indicates that the position should be set after the last character
             * of the editable. Note that `position` is in characters, not in bytes.
             * @param position the position of the cursor
             */
            set_position(position: number): void;
            /**
             * Sets the text in the editable to the given value.
             *
             * This is replacing the current contents.
             * @param text the text to set
             */
            set_text(text: string): void;
            /**
             * Changes the size request of the editable to be about the
             * right size for `n_chars` characters.
             *
             * Note that it changes the size request, the size can still
             * be affected by how you pack the widget into containers.
             * If `n_chars` is -1, the size reverts to the default size.
             * @param n_chars width in chars
             */
            set_width_chars(n_chars: number): void;
            vfunc_changed(): void;
            /**
             * Deletes a sequence of characters.
             *
             * The characters that are deleted are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters deleted are those from `start_pos` to
             * the end of the text.
             *
             * Note that the positions are specified in characters, not bytes.
             * @param start_pos start position
             * @param end_pos end position
             */
            vfunc_delete_text(start_pos: number, end_pos: number): void;
            /**
             * Deletes a sequence of characters.
             *
             * The characters that are deleted are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters deleted are those from `start_pos` to
             * the end of the text.
             *
             * Note that the positions are specified in characters, not bytes.
             * @param start_pos start position
             * @param end_pos end position
             */
            vfunc_do_delete_text(start_pos: number, end_pos: number): void;
            /**
             * Inserts `length` bytes of `text` into the contents of the
             * widget, at position `position`.
             *
             * Note that the position is in characters, not in bytes.
             * The function updates `position` to point after the newly
             * inserted text.
             * @param text the text to insert
             * @param length the length of the text in bytes, or -1
             * @param position location of the position text will be inserted at
             */
            vfunc_do_insert_text(text: string, length: number, position: number): number;
            /**
             * Gets the `GtkEditable` that `editable` is delegating its
             * implementation to.
             *
             * Typically, the delegate is a [class`Gtk`.Text] widget.
             */
            vfunc_get_delegate(): Editable | null;
            /**
             * Retrieves the selection bound of the editable.
             *
             * `start_pos` will be filled with the start of the selection and
             * `end_pos` with end. If no text was selected both will be identical
             * and %FALSE will be returned.
             *
             * Note that positions are specified in characters, not bytes.
             */
            vfunc_get_selection_bounds(): [boolean, number, number];
            /**
             * Retrieves the contents of `editable`.
             *
             * The returned string is owned by GTK and must not be modified or freed.
             */
            vfunc_get_text(): string;
            /**
             * Inserts `length` bytes of `text` into the contents of the
             * widget, at position `position`.
             *
             * Note that the position is in characters, not in bytes.
             * The function updates `position` to point after the newly
             * inserted text.
             * @param text the text to insert
             * @param length the length of the text in bytes, or -1
             * @param position location of the position text will be inserted at
             */
            vfunc_insert_text(text: string, length: number, position: number): number;
            /**
             * Selects a region of text.
             *
             * The characters that are selected are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters selected are those characters from
             * `start_pos` to  the end of the text.
             *
             * Note that positions are specified in characters, not bytes.
             * @param start_pos start of region
             * @param end_pos end of region
             */
            vfunc_set_selection_bounds(start_pos: number, end_pos: number): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace PasswordEntryBuffer {
            // Constructor properties interface

            interface ConstructorProps extends EntryBuffer.ConstructorProps {}
        }

        /**
         * A `GtkEntryBuffer` that locks the underlying memory to prevent it
         * from being swapped to disk.
         *
         * `GtkPasswordEntry` uses a `GtkPasswordEntryBuffer`.
         */
        class PasswordEntryBuffer extends EntryBuffer {
            static $gtype: GObject.GType<PasswordEntryBuffer>;

            // Constructors

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

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

            static ['new'](): PasswordEntryBuffer;
        }

        namespace Picture {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                alternative_text: string;
                alternativeText: string;
                can_shrink: boolean;
                canShrink: boolean;
                content_fit: ContentFit;
                contentFit: ContentFit;
                file: Gio.File;
                keep_aspect_ratio: boolean;
                keepAspectRatio: boolean;
                paintable: Gdk.Paintable;
            }
        }

        /**
         * The `GtkPicture` widget displays a `GdkPaintable`.
         *
         * ![An example GtkPicture](picture.png)
         *
         * Many convenience functions are provided to make pictures simple to use.
         * For example, if you want to load an image from a file, and then display
         * it, there’s a convenience function to do this:
         *
         * ```c
         * GtkWidget *widget = gtk_picture_new_for_filename ("myfile.png");
         * ```
         *
         * If the file isn’t loaded successfully, the picture will contain a
         * “broken image” icon similar to that used in many web browsers.
         * If you want to handle errors in loading the file yourself,
         * for example by displaying an error message, then load the image with
         * [ctor`Gdk`.Texture.new_from_file], then create the `GtkPicture` with
         * [ctor`Gtk`.Picture.new_for_paintable].
         *
         * Sometimes an application will want to avoid depending on external data
         * files, such as image files. See the documentation of `GResource` for details.
         * In this case, [ctor`Gtk`.Picture.new_for_resource] and
         * [method`Gtk`.Picture.set_resource] should be used.
         *
         * `GtkPicture` displays an image at its natural size. See [class`Gtk`.Image]
         * if you want to display a fixed-size image, such as an icon.
         *
         * ## Sizing the paintable
         *
         * You can influence how the paintable is displayed inside the `GtkPicture`
         * by changing [property`Gtk`.Picture:content-fit]. See [enum`Gtk`.ContentFit]
         * for details. [property`Gtk`.Picture:can-shrink] can be unset to make sure
         * that paintables are never made smaller than their ideal size - but
         * be careful if you do not know the size of the paintable in use (like
         * when displaying user-loaded images). This can easily cause the picture to
         * grow larger than the screen. And [property`Gtk`.Widget:halign] and
         * [property`Gtk`.Widget:valign] can be used to make sure the paintable doesn't
         * fill all available space but is instead displayed at its original size.
         *
         * ## CSS nodes
         *
         * `GtkPicture` has a single CSS node with the name `picture`.
         *
         * ## Accessibility
         *
         * `GtkPicture` uses the `GTK_ACCESSIBLE_ROLE_IMG` role.
         */
        class Picture extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<Picture>;

            // Properties

            /**
             * The alternative textual description for the picture.
             */
            get alternative_text(): string;
            set alternative_text(val: string);
            /**
             * The alternative textual description for the picture.
             */
            get alternativeText(): string;
            set alternativeText(val: string);
            /**
             * If the `GtkPicture` can be made smaller than the natural size of its contents.
             */
            get can_shrink(): boolean;
            set can_shrink(val: boolean);
            /**
             * If the `GtkPicture` can be made smaller than the natural size of its contents.
             */
            get canShrink(): boolean;
            set canShrink(val: boolean);
            /**
             * How the content should be resized to fit inside the `GtkPicture`.
             */
            get content_fit(): ContentFit;
            set content_fit(val: ContentFit);
            /**
             * How the content should be resized to fit inside the `GtkPicture`.
             */
            get contentFit(): ContentFit;
            set contentFit(val: ContentFit);
            /**
             * The `GFile` that is displayed or %NULL if none.
             */
            get file(): Gio.File;
            set file(val: Gio.File);
            /**
             * Whether the GtkPicture will render its contents trying to preserve the aspect
             * ratio.
             */
            get keep_aspect_ratio(): boolean;
            set keep_aspect_ratio(val: boolean);
            /**
             * Whether the GtkPicture will render its contents trying to preserve the aspect
             * ratio.
             */
            get keepAspectRatio(): boolean;
            set keepAspectRatio(val: boolean);
            /**
             * The `GdkPaintable` to be displayed by this `GtkPicture`.
             */
            get paintable(): Gdk.Paintable;
            set paintable(val: Gdk.Paintable);

            // Constructors

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

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

            static ['new'](): Picture;

            static new_for_file(file?: Gio.File | null): Picture;

            static new_for_filename(filename?: string | null): Picture;

            static new_for_paintable(paintable?: Gdk.Paintable | null): Picture;

            static new_for_pixbuf(pixbuf?: GdkPixbuf.Pixbuf | null): Picture;

            static new_for_resource(resource_path?: string | null): Picture;

            // Methods

            /**
             * Gets the alternative textual description of the picture.
             *
             * The returned string will be %NULL if the picture cannot be described textually.
             * @returns the alternative textual description of @self.
             */
            get_alternative_text(): string | null;
            /**
             * Returns whether the `GtkPicture` respects its contents size.
             * @returns %TRUE if the picture can be made smaller than its contents
             */
            get_can_shrink(): boolean;
            /**
             * Returns the fit mode for the content of the `GtkPicture`.
             *
             * See [enum`Gtk`.ContentFit] for details.
             * @returns the content fit mode
             */
            get_content_fit(): ContentFit;
            /**
             * Gets the `GFile` currently displayed if `self` is displaying a file.
             *
             * If `self` is not displaying a file, for example when
             * [method`Gtk`.Picture.set_paintable] was used, then %NULL is returned.
             * @returns The `GFile` displayed by @self.
             */
            get_file(): Gio.File | null;
            /**
             * Returns whether the `GtkPicture` preserves its contents aspect ratio.
             * @returns %TRUE if the self tries to keep the contents' aspect ratio
             */
            get_keep_aspect_ratio(): boolean;
            /**
             * Gets the `GdkPaintable` being displayed by the `GtkPicture`.
             * @returns the displayed paintable
             */
            get_paintable(): Gdk.Paintable | null;
            /**
             * Sets an alternative textual description for the picture contents.
             *
             * It is equivalent to the "alt" attribute for images on websites.
             *
             * This text will be made available to accessibility tools.
             *
             * If the picture cannot be described textually, set this property to %NULL.
             * @param alternative_text a textual description of the contents
             */
            set_alternative_text(alternative_text?: string | null): void;
            /**
             * If set to %TRUE, the `self` can be made smaller than its contents.
             *
             * The contents will then be scaled down when rendering.
             *
             * If you want to still force a minimum size manually, consider using
             * [method`Gtk`.Widget.set_size_request].
             *
             * Also of note is that a similar function for growing does not exist
             * because the grow behavior can be controlled via
             * [method`Gtk`.Widget.set_halign] and [method`Gtk`.Widget.set_valign].
             * @param can_shrink if @self can be made smaller than its contents
             */
            set_can_shrink(can_shrink: boolean): void;
            /**
             * Sets how the content should be resized to fit the `GtkPicture`.
             *
             * See [enum`Gtk`.ContentFit] for details.
             * @param content_fit the content fit mode
             */
            set_content_fit(content_fit: ContentFit | null): void;
            /**
             * Makes `self` load and display `file`.
             *
             * See [ctor`Gtk`.Picture.new_for_file] for details.
             * @param file a `GFile`
             */
            set_file(file?: Gio.File | null): void;
            /**
             * Makes `self` load and display the given `filename`.
             *
             * This is a utility function that calls [method`Gtk`.Picture.set_file].
             * @param filename the filename to play
             */
            set_filename(filename?: string | null): void;
            /**
             * If set to %TRUE, the `self` will render its contents according to
             * their aspect ratio.
             *
             * That means that empty space may show up at the top/bottom or
             * left/right of `self`.
             *
             * If set to %FALSE or if the contents provide no aspect ratio,
             * the contents will be stretched over the picture's whole area.
             * @param keep_aspect_ratio whether to keep aspect ratio
             */
            set_keep_aspect_ratio(keep_aspect_ratio: boolean): void;
            /**
             * Makes `self` display the given `paintable`.
             *
             * If `paintable` is %NULL, nothing will be displayed.
             *
             * See [ctor`Gtk`.Picture.new_for_paintable] for details.
             * @param paintable a `GdkPaintable`
             */
            set_paintable(paintable?: Gdk.Paintable | null): void;
            /**
             * Sets a `GtkPicture` to show a `GdkPixbuf`.
             *
             * See [ctor`Gtk`.Picture.new_for_pixbuf] for details.
             *
             * This is a utility function that calls [method`Gtk`.Picture.set_paintable].
             * @param pixbuf a `GdkPixbuf`
             */
            set_pixbuf(pixbuf?: GdkPixbuf.Pixbuf | null): void;
            /**
             * Makes `self` load and display the resource at the given
             * `resource_path`.
             *
             * This is a utility function that calls [method`Gtk`.Picture.set_file].
             * @param resource_path the resource to set
             */
            set_resource(resource_path?: string | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Popover {
            // Signal callback interfaces

            interface ActivateDefault {
                (): void;
            }

            interface Closed {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Native.ConstructorProps,
                    ShortcutManager.ConstructorProps {
                autohide: boolean;
                cascade_popdown: boolean;
                cascadePopdown: boolean;
                child: Widget;
                default_widget: Widget;
                defaultWidget: Widget;
                has_arrow: boolean;
                hasArrow: boolean;
                mnemonics_visible: boolean;
                mnemonicsVisible: boolean;
                pointing_to: Gdk.Rectangle;
                pointingTo: Gdk.Rectangle;
                position: PositionType;
            }
        }

        /**
         * `GtkPopover` is a bubble-like context popup.
         *
         * ![An example GtkPopover](popover.png)
         *
         * It is primarily meant to provide context-dependent information
         * or options. Popovers are attached to a parent widget. By default,
         * they point to the whole widget area, although this behavior can be
         * changed with [method`Gtk`.Popover.set_pointing_to].
         *
         * The position of a popover relative to the widget it is attached to
         * can also be changed with [method`Gtk`.Popover.set_position]
         *
         * By default, `GtkPopover` performs a grab, in order to ensure input
         * events get redirected to it while it is shown, and also so the popover
         * is dismissed in the expected situations (clicks outside the popover,
         * or the Escape key being pressed). If no such modal behavior is desired
         * on a popover, [method`Gtk`.Popover.set_autohide] may be called on it to
         * tweak its behavior.
         *
         * ## GtkPopover as menu replacement
         *
         * `GtkPopover` is often used to replace menus. The best way to do this
         * is to use the [class`Gtk`.PopoverMenu] subclass which supports being
         * populated from a `GMenuModel` with [ctor`Gtk`.PopoverMenu.new_from_model].
         *
         * ```xml
         * <section>
         *   <attribute name="display-hint">horizontal-buttons</attribute>
         *   <item>
         *     <attribute name="label">Cut</attribute>
         *     <attribute name="action">app.cut</attribute>
         *     <attribute name="verb-icon">edit-cut-symbolic</attribute>
         *   </item>
         *   <item>
         *     <attribute name="label">Copy</attribute>
         *     <attribute name="action">app.copy</attribute>
         *     <attribute name="verb-icon">edit-copy-symbolic</attribute>
         *   </item>
         *   <item>
         *     <attribute name="label">Paste</attribute>
         *     <attribute name="action">app.paste</attribute>
         *     <attribute name="verb-icon">edit-paste-symbolic</attribute>
         *   </item>
         * </section>
         * ```
         *
         * # Shortcuts and Gestures
         *
         * `GtkPopover` supports the following keyboard shortcuts:
         *
         * - <kbd>Escape</kbd> closes the popover.
         * - <kbd>Alt</kbd> makes the mnemonics visible.
         *
         * The following signals have default keybindings:
         *
         * - [signal`Gtk`.Popover::activate-default]
         *
         * # CSS nodes
         *
         * ```
         * popover.background[.menu]
         * ├── arrow
         * ╰── contents
         *     ╰── <child>
         * ```
         *
         * `GtkPopover` has a main node with name `popover`, an arrow with name `arrow`,
         * and another node for the content named `contents`. The `popover` node always
         * gets the `.background` style class. It also gets the `.menu` style class
         * if the popover is menu-like, e.g. is a [class`Gtk`.PopoverMenu].
         *
         * Particular uses of `GtkPopover`, such as touch selection popups or
         * magnifiers in `GtkEntry` or `GtkTextView` get style classes like
         * `.touch-selection` or `.magnifier` to differentiate from plain popovers.
         *
         * When styling a popover directly, the `popover` node should usually
         * not have any background. The visible part of the popover can have
         * a shadow. To specify it in CSS, set the box-shadow of the `contents` node.
         *
         * Note that, in order to accomplish appropriate arrow visuals, `GtkPopover`
         * uses custom drawing for the `arrow` node. This makes it possible for the
         * arrow to change its shape dynamically, but it also limits the possibilities
         * of styling it using CSS. In particular, the `arrow` gets drawn over the
         * `content` node's border and shadow, so they look like one shape, which
         * means that the border width of the `content` node and the `arrow` node should
         * be the same. The arrow also does not support any border shape other than
         * solid, no border-radius, only one border width (border-bottom-width is
         * used) and no box-shadow.
         */
        class Popover extends Widget implements Accessible, Buildable, ConstraintTarget, Native, ShortcutManager {
            static $gtype: GObject.GType<Popover>;

            // Properties

            /**
             * Whether to dismiss the popover on outside clicks.
             */
            get autohide(): boolean;
            set autohide(val: boolean);
            /**
             * Whether the popover pops down after a child popover.
             *
             * This is used to implement the expected behavior of submenus.
             */
            get cascade_popdown(): boolean;
            set cascade_popdown(val: boolean);
            /**
             * Whether the popover pops down after a child popover.
             *
             * This is used to implement the expected behavior of submenus.
             */
            get cascadePopdown(): boolean;
            set cascadePopdown(val: boolean);
            /**
             * The child widget.
             */
            get child(): Widget;
            set child(val: Widget);
            /**
             * The default widget inside the popover.
             */
            get default_widget(): Widget;
            set default_widget(val: Widget);
            /**
             * The default widget inside the popover.
             */
            get defaultWidget(): Widget;
            set defaultWidget(val: Widget);
            /**
             * Whether to draw an arrow.
             */
            get has_arrow(): boolean;
            set has_arrow(val: boolean);
            /**
             * Whether to draw an arrow.
             */
            get hasArrow(): boolean;
            set hasArrow(val: boolean);
            /**
             * Whether mnemonics are currently visible in this popover.
             */
            get mnemonics_visible(): boolean;
            set mnemonics_visible(val: boolean);
            /**
             * Whether mnemonics are currently visible in this popover.
             */
            get mnemonicsVisible(): boolean;
            set mnemonicsVisible(val: boolean);
            /**
             * Rectangle in the parent widget that the popover points to.
             */
            get pointing_to(): Gdk.Rectangle;
            set pointing_to(val: Gdk.Rectangle);
            /**
             * Rectangle in the parent widget that the popover points to.
             */
            get pointingTo(): Gdk.Rectangle;
            set pointingTo(val: Gdk.Rectangle);
            /**
             * How to place the popover, relative to its parent.
             */
            get position(): PositionType;
            set position(val: PositionType);

            // Constructors

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

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

            static ['new'](): Popover;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate-default', callback: (_source: this) => void): number;
            connect_after(signal: 'activate-default', callback: (_source: this) => void): number;
            emit(signal: 'activate-default'): void;
            connect(signal: 'closed', callback: (_source: this) => void): number;
            connect_after(signal: 'closed', callback: (_source: this) => void): number;
            emit(signal: 'closed'): void;

            // Virtual methods

            vfunc_activate_default(): void;
            vfunc_closed(): void;

            // Methods

            /**
             * Returns whether the popover is modal.
             *
             * See [method`Gtk`.Popover.set_autohide] for the
             * implications of this.
             * @returns %TRUE if @popover is modal
             */
            get_autohide(): boolean;
            /**
             * Returns whether the popover will close after a modal child is closed.
             * @returns %TRUE if @popover will close after a modal child.
             */
            get_cascade_popdown(): boolean;
            /**
             * Gets the child widget of `popover`.
             * @returns the child widget of @popover
             */
            get_child(): Widget | null;
            /**
             * Gets whether this popover is showing an arrow
             * pointing at the widget that it is relative to.
             * @returns whether the popover has an arrow
             */
            get_has_arrow(): boolean;
            /**
             * Gets whether mnemonics are visible.
             * @returns %TRUE if mnemonics are supposed to be visible   in this popover
             */
            get_mnemonics_visible(): boolean;
            /**
             * Gets the offset previous set with [method`Gtk`.Popover.set_offset()].
             */
            get_offset(): [number, number];
            /**
             * Gets the rectangle that the popover points to.
             *
             * If a rectangle to point to has been set, this function will
             * return %TRUE and fill in `rect` with such rectangle, otherwise
             * it will return %FALSE and fill in `rect` with the parent
             * widget coordinates.
             * @returns %TRUE if a rectangle to point to was set.
             */
            get_pointing_to(): [boolean, Gdk.Rectangle];
            /**
             * Returns the preferred position of `popover`.
             * @returns The preferred position.
             */
            get_position(): PositionType;
            /**
             * Pops `popover` down.
             *
             * This may have the side-effect of closing a parent popover
             * as well. See [property`Gtk`.Popover:cascade-popdown].
             */
            popdown(): void;
            /**
             * Pops `popover` up.
             */
            popup(): void;
            /**
             * Allocate a size for the `GtkPopover`.
             *
             * This function needs to be called in size-allocate by widgets
             * who have a `GtkPopover` as child. When using a layout manager,
             * this is happening automatically.
             *
             * To make a popover appear on screen, use [method`Gtk`.Popover.popup].
             */
            present(): void;
            /**
             * Sets whether `popover` is modal.
             *
             * A modal popover will grab the keyboard focus on it when being
             * displayed. Focus will wrap around within the popover. Clicking
             * outside the popover area or pressing Esc will dismiss the popover.
             *
             * Called this function on an already showing popup with a new
             * autohide value different from the current one, will cause the
             * popup to be hidden.
             * @param autohide %TRUE to dismiss the popover on outside clicks
             */
            set_autohide(autohide: boolean): void;
            /**
             * If `cascade_popdown` is %TRUE, the popover will be
             * closed when a child modal popover is closed.
             *
             * If %FALSE, `popover` will stay visible.
             * @param cascade_popdown %TRUE if the popover should follow a child closing
             */
            set_cascade_popdown(cascade_popdown: boolean): void;
            /**
             * Sets the child widget of `popover`.
             * @param child the child widget
             */
            set_child(child?: Widget | null): void;
            /**
             * Sets the default widget of a `GtkPopover`.
             *
             * The default widget is the widget that’s activated when the user
             * presses Enter in a dialog (for example). This function sets or
             * unsets the default widget for a `GtkPopover`.
             * @param widget a child widget of @popover to set as   the default, or %NULL to unset the default widget for the popover
             */
            set_default_widget(widget?: Widget | null): void;
            /**
             * Sets whether this popover should draw an arrow
             * pointing at the widget it is relative to.
             * @param has_arrow %TRUE to draw an arrow
             */
            set_has_arrow(has_arrow: boolean): void;
            /**
             * Sets whether mnemonics should be visible.
             * @param mnemonics_visible the new value
             */
            set_mnemonics_visible(mnemonics_visible: boolean): void;
            /**
             * Sets the offset to use when calculating the position
             * of the popover.
             *
             * These values are used when preparing the [struct`Gdk`.PopupLayout]
             * for positioning the popover.
             * @param x_offset the x offset to adjust the position by
             * @param y_offset the y offset to adjust the position by
             */
            set_offset(x_offset: number, y_offset: number): void;
            /**
             * Sets the rectangle that `popover` points to.
             *
             * This is in the coordinate space of the `popover` parent.
             * @param rect rectangle to point to
             */
            set_pointing_to(rect?: Gdk.Rectangle | null): void;
            /**
             * Sets the preferred position for `popover` to appear.
             *
             * If the `popover` is currently visible, it will be immediately
             * updated.
             *
             * This preference will be respected where possible, although
             * on lack of space (eg. if close to the window edges), the
             * `GtkPopover` may choose to appear on the opposite side.
             * @param position preferred popover position
             */
            set_position(position: PositionType | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Returns the renderer that is used for this `GtkNative`.
             * @returns the renderer for @self
             */
            get_renderer(): Gsk.Renderer | null;
            /**
             * Returns the surface of this `GtkNative`.
             * @returns the surface of @self
             */
            get_surface(): Gdk.Surface | null;
            /**
             * Retrieves the surface transform of `self`.
             *
             * This is the translation from `self'`s surface coordinates into
             * `self'`s widget coordinates.
             */
            get_surface_transform(): [number, number];
            /**
             * Realizes a `GtkNative`.
             *
             * This should only be used by subclasses.
             */
            realize(): void;
            /**
             * Unrealizes a `GtkNative`.
             *
             * This should only be used by subclasses.
             */
            unrealize(): void;
            /**
             * Add a `GtkShortcutController` to be managed.
             * @param controller
             */
            vfunc_add_controller(controller: ShortcutController): void;
            /**
             * Remove a `GtkShortcutController` that had previously
             *   been added
             * @param controller
             */
            vfunc_remove_controller(controller: ShortcutController): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace PopoverMenu {
            // Constructor properties interface

            interface ConstructorProps
                extends Popover.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Native.ConstructorProps,
                    ShortcutManager.ConstructorProps {
                flags: PopoverMenuFlags;
                menu_model: Gio.MenuModel;
                menuModel: Gio.MenuModel;
                visible_submenu: string;
                visibleSubmenu: string;
            }
        }

        /**
         * `GtkPopoverMenu` is a subclass of `GtkPopover` that implements menu
         * behavior.
         *
         * ![An example GtkPopoverMenu](menu.png)
         *
         * `GtkPopoverMenu` treats its children like menus and allows switching
         * between them. It can open submenus as traditional, nested submenus,
         * or in a more touch-friendly sliding fashion.
         * The property [property`Gtk`.PopoverMenu:flags] controls this appearance.
         *
         * `GtkPopoverMenu` is meant to be used primarily with menu models,
         * using [ctor`Gtk`.PopoverMenu.new_from_model]. If you need to put
         * other widgets such as a `GtkSpinButton` or a `GtkSwitch` into a popover,
         * you can use [method`Gtk`.PopoverMenu.add_child].
         *
         * For more dialog-like behavior, use a plain `GtkPopover`.
         *
         * ## Menu models
         *
         * The XML format understood by `GtkBuilder` for `GMenuModel` consists
         * of a toplevel `<menu>` element, which contains one or more `<item>`
         * elements. Each `<item>` element contains `<attribute>` and `<link>`
         * elements with a mandatory name attribute. `<link>` elements have the
         * same content model as `<menu>`. Instead of `<link name="submenu">`
         * or `<link name="section">`, you can use `<submenu>` or `<section>`
         * elements.
         *
         * ```xml
         * <menu id='app-menu'>
         *   <section>
         *     <item>
         *       <attribute name='label' translatable='yes'>_New Window</attribute>
         *       <attribute name='action'>app.new</attribute>
         *     </item>
         *     <item>
         *       <attribute name='label' translatable='yes'>_About Sunny</attribute>
         *       <attribute name='action'>app.about</attribute>
         *     </item>
         *     <item>
         *       <attribute name='label' translatable='yes'>_Quit</attribute>
         *       <attribute name='action'>app.quit</attribute>
         *     </item>
         *   </section>
         * </menu>
         * ```
         *
         * Attribute values can be translated using gettext, like other `GtkBuilder`
         * content. `<attribute>` elements can be marked for translation with a
         * `translatable="yes"` attribute. It is also possible to specify message
         * context and translator comments, using the context and comments attributes.
         * To make use of this, the `GtkBuilder` must have been given the gettext
         * domain to use.
         *
         * The following attributes are used when constructing menu items:
         *
         * - "label": a user-visible string to display
         * - "use-markup": whether the text in the menu item includes [Pango markup](https://docs.gtk.org/Pango/pango_markup.html)
         * - "action": the prefixed name of the action to trigger
         * - "target": the parameter to use when activating the action
         * - "icon" and "verb-icon": names of icons that may be displayed
         * - "submenu-action": name of an action that may be used to track
         *      whether a submenu is open
         * - "hidden-when": a string used to determine when the item will be hidden.
         *      Possible values include "action-disabled", "action-missing", "macos-menubar".
         *      This is mainly useful for exported menus, see [method`Gtk`.Application.set_menubar].
         * - "custom": a string used to match against the ID of a custom child added with
         *      [method`Gtk`.PopoverMenu.add_child], [method`Gtk`.PopoverMenuBar.add_child],
         *      or in the ui file with `<child type="ID">`.
         *
         * The following attributes are used when constructing sections:
         *
         * - "label": a user-visible string to use as section heading
         * - "display-hint": a string used to determine special formatting for the section.
         *     Possible values include "horizontal-buttons", "circular-buttons" and
         *     "inline-buttons". They all indicate that section should be
         *     displayed as a horizontal row of buttons.
         * - "text-direction": a string used to determine the `GtkTextDirection` to use
         *     when "display-hint" is set to "horizontal-buttons". Possible values
         *     include "rtl", "ltr", and "none".
         *
         * The following attributes are used when constructing submenus:
         *
         * - "label": a user-visible string to display
         * - "icon": icon name to display
         *
         * Menu items will also show accelerators, which are usually associated
         * with actions via [method`Gtk`.Application.set_accels_for_action],
         * [method`WidgetClass`.add_binding_action] or
         * [method`Gtk`.ShortcutController.add_shortcut].
         *
         * # Shortcuts and Gestures
         *
         * `GtkPopoverMenu` supports the following keyboard shortcuts:
         *
         * - <kbd>Space</kbd> activates the default widget.
         *
         * # CSS Nodes
         *
         * `GtkPopoverMenu` is just a subclass of `GtkPopover` that adds custom content
         * to it, therefore it has the same CSS nodes. It is one of the cases that add
         * a `.menu` style class to the main `popover` node.
         *
         * Menu items have nodes with name `button` and class `.model`. If a section
         * display-hint is set, the section gets a node `box` with class `horizontal`
         * plus a class with the same text as the display hint. Note that said box may
         * not be the direct ancestor of the item `button`s. Thus, for example, to style
         * items in an `inline-buttons` section, select `.inline-buttons button.model`.
         * Other things that may be of interest to style in menus include `label` nodes.
         *
         * # Accessibility
         *
         * `GtkPopoverMenu` uses the %GTK_ACCESSIBLE_ROLE_MENU role, and its
         * items use the %GTK_ACCESSIBLE_ROLE_MENU_ITEM,
         * %GTK_ACCESSIBLE_ROLE_MENU_ITEM_CHECKBOX or
         * %GTK_ACCESSIBLE_ROLE_MENU_ITEM_RADIO roles, depending on the
         * action they are connected to.
         */
        class PopoverMenu extends Popover implements Accessible, Buildable, ConstraintTarget, Native, ShortcutManager {
            static $gtype: GObject.GType<PopoverMenu>;

            // Properties

            /**
             * The flags that `popover` uses to create/display a menu from its model.
             *
             * If a model is set and the flags change, contents are rebuilt, so if setting
             * properties individually, set flags before model to avoid a redundant rebuild.
             */
            get flags(): PopoverMenuFlags;
            set flags(val: PopoverMenuFlags);
            /**
             * The model from which the menu is made.
             */
            get menu_model(): Gio.MenuModel;
            set menu_model(val: Gio.MenuModel);
            /**
             * The model from which the menu is made.
             */
            get menuModel(): Gio.MenuModel;
            set menuModel(val: Gio.MenuModel);
            /**
             * The name of the visible submenu.
             */
            get visible_submenu(): string;
            set visible_submenu(val: string);
            /**
             * The name of the visible submenu.
             */
            get visibleSubmenu(): string;
            set visibleSubmenu(val: string);

            // Constructors

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

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

            static new_from_model(model?: Gio.MenuModel | null): PopoverMenu;

            static new_from_model_full(model: Gio.MenuModel, flags: PopoverMenuFlags): PopoverMenu;

            // Methods

            /**
             * Adds a custom widget to a generated menu.
             *
             * For this to work, the menu model of `popover` must have
             * an item with a `custom` attribute that matches `id`.
             * @param child the `GtkWidget` to add
             * @param id the ID to insert @child at
             * @returns %TRUE if @id was found and the widget added
             */
            add_child(child: Widget, id: string): boolean;
            /**
             * Returns the flags that `popover` uses to create/display a menu from its model.
             * @returns the `GtkPopoverMenuFlags`
             */
            get_flags(): PopoverMenuFlags;
            /**
             * Returns the menu model used to populate the popover.
             * @returns the menu model of @popover
             */
            get_menu_model(): Gio.MenuModel | null;
            /**
             * Removes a widget that has previously been added with
             * [method`Gtk`.PopoverMenu.add_child()]
             * @param child the `GtkWidget` to remove
             * @returns %TRUE if the widget was removed
             */
            remove_child(child: Widget): boolean;
            /**
             * Sets the flags that `popover` uses to create/display a menu from its model.
             *
             * If a model is set and the flags change, contents are rebuilt, so if setting
             * properties individually, set flags before model to avoid a redundant rebuild.
             * @param flags a set of `GtkPopoverMenuFlags`
             */
            set_flags(flags: PopoverMenuFlags | null): void;
            /**
             * Sets a new menu model on `popover`.
             *
             * The existing contents of `popover` are removed, and
             * the `popover` is populated with new contents according
             * to `model`.
             * @param model a `GMenuModel`
             */
            set_menu_model(model?: Gio.MenuModel | null): void;

            // Inherited properties
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Returns the renderer that is used for this `GtkNative`.
             * @returns the renderer for @self
             */
            get_renderer(): Gsk.Renderer | null;
            /**
             * Returns the surface of this `GtkNative`.
             * @returns the surface of @self
             */
            get_surface(): Gdk.Surface | null;
            /**
             * Retrieves the surface transform of `self`.
             *
             * This is the translation from `self'`s surface coordinates into
             * `self'`s widget coordinates.
             */
            get_surface_transform(): [number, number];
            /**
             * Realizes a `GtkNative`.
             *
             * This should only be used by subclasses.
             */
            realize(): void;
            /**
             * Unrealizes a `GtkNative`.
             *
             * This should only be used by subclasses.
             */
            unrealize(): void;
            /**
             * Add a `GtkShortcutController` to be managed.
             * @param controller
             */
            vfunc_add_controller(controller: ShortcutController): void;
            /**
             * Remove a `GtkShortcutController` that had previously
             *   been added
             * @param controller
             */
            vfunc_remove_controller(controller: ShortcutController): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace PopoverMenuBar {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                menu_model: Gio.MenuModel;
                menuModel: Gio.MenuModel;
            }
        }

        /**
         * `GtkPopoverMenuBar` presents a horizontal bar of items that pop
         * up popover menus when clicked.
         *
         * ![An example GtkPopoverMenuBar](menubar.png)
         *
         * The only way to create instances of `GtkPopoverMenuBar` is
         * from a `GMenuModel`.
         *
         * # CSS nodes
         *
         * ```
         * menubar
         * ├── item[.active]
         * ┊   ╰── popover
         * ╰── item
         *     ╰── popover
         * ```
         *
         * `GtkPopoverMenuBar` has a single CSS node with name menubar, below which
         * each item has its CSS node, and below that the corresponding popover.
         *
         * The item whose popover is currently open gets the .active
         * style class.
         *
         * # Accessibility
         *
         * `GtkPopoverMenuBar` uses the %GTK_ACCESSIBLE_ROLE_MENU_BAR role,
         * the menu items use the %GTK_ACCESSIBLE_ROLE_MENU_ITEM role and
         * the menus use the %GTK_ACCESSIBLE_ROLE_MENU role.
         */
        class PopoverMenuBar extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<PopoverMenuBar>;

            // Properties

            /**
             * The `GMenuModel` from which the menu bar is created.
             *
             * The model should only contain submenus as toplevel elements.
             */
            get menu_model(): Gio.MenuModel;
            set menu_model(val: Gio.MenuModel);
            /**
             * The `GMenuModel` from which the menu bar is created.
             *
             * The model should only contain submenus as toplevel elements.
             */
            get menuModel(): Gio.MenuModel;
            set menuModel(val: Gio.MenuModel);

            // Constructors

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

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

            static new_from_model(model?: Gio.MenuModel | null): PopoverMenuBar;

            // Methods

            /**
             * Adds a custom widget to a generated menubar.
             *
             * For this to work, the menu model of `bar` must have an
             * item with a `custom` attribute that matches `id`.
             * @param child the `GtkWidget` to add
             * @param id the ID to insert @child at
             * @returns %TRUE if @id was found and the widget added
             */
            add_child(child: Widget, id: string): boolean;
            /**
             * Returns the model from which the contents of `bar` are taken.
             * @returns a `GMenuModel`
             */
            get_menu_model(): Gio.MenuModel | null;
            /**
             * Removes a widget that has previously been added with
             * gtk_popover_menu_bar_add_child().
             * @param child the `GtkWidget` to remove
             * @returns %TRUE if the widget was removed
             */
            remove_child(child: Widget): boolean;
            /**
             * Sets a menu model from which `bar` should take
             * its contents.
             * @param model a `GMenuModel`
             */
            set_menu_model(model?: Gio.MenuModel | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace PrintContext {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * A `GtkPrintContext` encapsulates context information that is required when
         * drawing pages for printing.
         *
         * This includes the cairo context and important parameters like page size
         * and resolution. It also lets you easily create [class`Pango`.Layout] and
         * [class`Pango`.Context] objects that match the font metrics of the cairo surface.
         *
         * `GtkPrintContext` objects get passed to the
         * [signal`Gtk`.PrintOperation::begin-print],
         * [signal`Gtk`.PrintOperation::end-print],
         * [signal`Gtk`.PrintOperation::request-page-setup] and
         * [signal`Gtk`.PrintOperation::draw-page] signals on the
         * [class`Gtk`.PrintOperation] object.
         *
         * ## Using GtkPrintContext in a ::draw-page callback
         *
         * ```c
         * static void
         * draw_page (GtkPrintOperation *operation,
         *            GtkPrintContext   *context,
         *            int                page_nr)
         * {
         *   cairo_t *cr;
         *   PangoLayout *layout;
         *   PangoFontDescription *desc;
         *
         *   cr = gtk_print_context_get_cairo_context (context);
         *
         *   // Draw a red rectangle, as wide as the paper (inside the margins)
         *   cairo_set_source_rgb (cr, 1.0, 0, 0);
         *   cairo_rectangle (cr, 0, 0, gtk_print_context_get_width (context), 50);
         *
         *   cairo_fill (cr);
         *
         *   // Draw some lines
         *   cairo_move_to (cr, 20, 10);
         *   cairo_line_to (cr, 40, 20);
         *   cairo_arc (cr, 60, 60, 20, 0, M_PI);
         *   cairo_line_to (cr, 80, 20);
         *
         *   cairo_set_source_rgb (cr, 0, 0, 0);
         *   cairo_set_line_width (cr, 5);
         *   cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
         *   cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
         *
         *   cairo_stroke (cr);
         *
         *   // Draw some text
         *   layout = gtk_print_context_create_pango_layout (context);
         *   pango_layout_set_text (layout, "Hello World! Printing is easy", -1);
         *   desc = pango_font_description_from_string ("sans 28");
         *   pango_layout_set_font_description (layout, desc);
         *   pango_font_description_free (desc);
         *
         *   cairo_move_to (cr, 30, 20);
         *   pango_cairo_layout_path (cr, layout);
         *
         *   // Font Outline
         *   cairo_set_source_rgb (cr, 0.93, 1.0, 0.47);
         *   cairo_set_line_width (cr, 0.5);
         *   cairo_stroke_preserve (cr);
         *
         *   // Font Fill
         *   cairo_set_source_rgb (cr, 0, 0.0, 1.0);
         *   cairo_fill (cr);
         *
         *   g_object_unref (layout);
         * }
         * ```
         */
        class PrintContext extends GObject.Object {
            static $gtype: GObject.GType<PrintContext>;

            // Constructors

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

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

            // Methods

            /**
             * Creates a new `PangoContext` that can be used with the
             * `GtkPrintContext`.
             * @returns a new Pango context for @context
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` that is suitable for use
             * with the `GtkPrintContext`.
             * @returns a new Pango layout for @context
             */
            create_pango_layout(): Pango.Layout;
            /**
             * Obtains the cairo context that is associated with the
             * `GtkPrintContext`.
             * @returns the cairo context of @context
             */
            get_cairo_context(): cairo.Context;
            /**
             * Obtains the horizontal resolution of the `GtkPrintContext`,
             * in dots per inch.
             * @returns the horizontal resolution of @context
             */
            get_dpi_x(): number;
            /**
             * Obtains the vertical resolution of the `GtkPrintContext`,
             * in dots per inch.
             * @returns the vertical resolution of @context
             */
            get_dpi_y(): number;
            /**
             * Obtains the hardware printer margins of the `GtkPrintContext`,
             * in units.
             * @returns %TRUE if the hard margins were retrieved
             */
            get_hard_margins(): [boolean, number, number, number, number];
            /**
             * Obtains the height of the `GtkPrintContext`, in pixels.
             * @returns the height of @context
             */
            get_height(): number;
            /**
             * Obtains the `GtkPageSetup` that determines the page
             * dimensions of the `GtkPrintContext`.
             * @returns the page setup of @context
             */
            get_page_setup(): PageSetup;
            /**
             * Returns a `PangoFontMap` that is suitable for use
             * with the `GtkPrintContext`.
             * @returns the font map of @context
             */
            get_pango_fontmap(): Pango.FontMap;
            /**
             * Obtains the width of the `GtkPrintContext`, in pixels.
             * @returns the width of @context
             */
            get_width(): number;
            /**
             * Sets a new cairo context on a print context.
             *
             * This function is intended to be used when implementing
             * an internal print preview, it is not needed for printing,
             * since GTK itself creates a suitable cairo context in that
             * case.
             * @param cr the cairo context
             * @param dpi_x the horizontal resolution to use with @cr
             * @param dpi_y the vertical resolution to use with @cr
             */
            set_cairo_context(cr: cairo.Context, dpi_x: number, dpi_y: number): void;
        }

        namespace PrintDialog {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                accept_label: string;
                acceptLabel: string;
                modal: boolean;
                page_setup: PageSetup;
                pageSetup: PageSetup;
                print_settings: PrintSettings;
                printSettings: PrintSettings;
                title: string;
            }
        }

        /**
         * A `GtkPrintDialog` object collects the arguments that
         * are needed to present a print dialog to the user, such
         * as a title for the dialog and whether it should be modal.
         *
         * The dialog is shown with the [method`Gtk`.PrintDialog.setup] function.
         * The actual printing can be done with [method`Gtk`.PrintDialog.print] or
         * [method`Gtk`.PrintDialog.print_file]. These APIs follows the GIO async pattern,
         * and the results can be obtained by calling the corresponding finish methods.
         */
        class PrintDialog extends GObject.Object {
            static $gtype: GObject.GType<PrintDialog>;

            // Properties

            /**
             * A label that may be shown on the accept button of a print dialog
             * that is presented by [method`Gtk`.PrintDialog.setup].
             */
            get accept_label(): string;
            set accept_label(val: string);
            /**
             * A label that may be shown on the accept button of a print dialog
             * that is presented by [method`Gtk`.PrintDialog.setup].
             */
            get acceptLabel(): string;
            set acceptLabel(val: string);
            /**
             * Whether the print dialog is modal.
             */
            get modal(): boolean;
            set modal(val: boolean);
            /**
             * The page setup to use.
             */
            get page_setup(): PageSetup;
            set page_setup(val: PageSetup);
            /**
             * The page setup to use.
             */
            get pageSetup(): PageSetup;
            set pageSetup(val: PageSetup);
            /**
             * The print settings to use.
             */
            get print_settings(): PrintSettings;
            set print_settings(val: PrintSettings);
            /**
             * The print settings to use.
             */
            get printSettings(): PrintSettings;
            set printSettings(val: PrintSettings);
            /**
             * A title that may be shown on the print dialog that is
             * presented by [method`Gtk`.PrintDialog.setup].
             */
            get title(): string;
            set title(val: string);

            // Constructors

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

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

            static ['new'](): PrintDialog;

            // Methods

            /**
             * Returns the label that will be shown on the
             * accept button of the print dialog.
             * @returns the accept label
             */
            get_accept_label(): string;
            /**
             * Returns whether the print dialog blocks
             * interaction with the parent window while
             * it is presented.
             * @returns whether the print dialog is modal
             */
            get_modal(): boolean;
            /**
             * Returns the page setup.
             * @returns the page setup
             */
            get_page_setup(): PageSetup | null;
            /**
             * Returns the print settings for the print dialog.
             * @returns the settings
             */
            get_print_settings(): PrintSettings | null;
            /**
             * Returns the title that will be shown on the
             * print dialog.
             * @returns the title
             */
            get_title(): string;
            /**
             * This function prints content from a stream.
             *
             * If you pass `NULL` as `setup,` then this method will present a print dialog.
             * Otherwise, it will attempt to print directly, without user interaction.
             *
             * The `callback` will be called when the printing is done.
             * @param parent the parent `GtkWindow`
             * @param setup the `GtkPrintSetup` to use
             * @param cancellable a `GCancellable` to cancel the operation
             */
            print(
                parent?: Window | null,
                setup?: PrintSetup | null,
                cancellable?: Gio.Cancellable | null,
            ): Promise<Gio.OutputStream>;
            /**
             * This function prints content from a stream.
             *
             * If you pass `NULL` as `setup,` then this method will present a print dialog.
             * Otherwise, it will attempt to print directly, without user interaction.
             *
             * The `callback` will be called when the printing is done.
             * @param parent the parent `GtkWindow`
             * @param setup the `GtkPrintSetup` to use
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            print(
                parent: Window | null,
                setup: PrintSetup | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * This function prints content from a stream.
             *
             * If you pass `NULL` as `setup,` then this method will present a print dialog.
             * Otherwise, it will attempt to print directly, without user interaction.
             *
             * The `callback` will be called when the printing is done.
             * @param parent the parent `GtkWindow`
             * @param setup the `GtkPrintSetup` to use
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            print(
                parent?: Window | null,
                setup?: PrintSetup | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<Gio.OutputStream> | void;
            /**
             * This function prints a file.
             *
             * If you pass `NULL` as `setup,` then this method will present a print dialog.
             * Otherwise, it will attempt to print directly, without user interaction.
             * @param parent the parent `GtkWindow`
             * @param setup the `GtkPrintSetup` to use
             * @param file the `GFile` to print
             * @param cancellable a `GCancellable` to cancel the operation
             */
            print_file(
                parent: Window | null,
                setup: PrintSetup | null,
                file: Gio.File,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * This function prints a file.
             *
             * If you pass `NULL` as `setup,` then this method will present a print dialog.
             * Otherwise, it will attempt to print directly, without user interaction.
             * @param parent the parent `GtkWindow`
             * @param setup the `GtkPrintSetup` to use
             * @param file the `GFile` to print
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            print_file(
                parent: Window | null,
                setup: PrintSetup | null,
                file: Gio.File,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * This function prints a file.
             *
             * If you pass `NULL` as `setup,` then this method will present a print dialog.
             * Otherwise, it will attempt to print directly, without user interaction.
             * @param parent the parent `GtkWindow`
             * @param setup the `GtkPrintSetup` to use
             * @param file the `GFile` to print
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            print_file(
                parent: Window | null,
                setup: PrintSetup | null,
                file: Gio.File,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes the [method`Gtk`.PrintDialog.print_file] call and
             * returns the results.
             * @param result a `GAsyncResult`
             * @returns Whether the call was successful
             */
            print_file_finish(result: Gio.AsyncResult): boolean;
            /**
             * Finishes the [method`Gtk`.PrintDialog.print] call and
             * returns the results.
             *
             * If the call was successful, the content to be printed should be
             * written to the returned output stream. Otherwise, `NULL` is returned.
             *
             * The overall results of the print operation will be returned in the
             * [method`Gio`.OutputStream.close] call, so if you are interested in the
             * results, you need to explicitly close the output stream (it will be
             * closed automatically if you just unref it). Be aware that the close
             * call may not be instant as it operation will for the printer to finish
             * printing.
             * @param result a `GAsyncResult`
             * @returns a [class@Gio.OutputStream]
             */
            print_finish(result: Gio.AsyncResult): Gio.OutputStream;
            /**
             * Sets the label that will be shown on the
             * accept button of the print dialog shown for
             * [method`Gtk`.PrintDialog.setup].
             * @param accept_label the new accept label
             */
            set_accept_label(accept_label: string): void;
            /**
             * Sets whether the print dialog blocks
             * interaction with the parent window while
             * it is presented.
             * @param modal the new value
             */
            set_modal(modal: boolean): void;
            /**
             * Set the page setup for the print dialog.
             * @param page_setup the new page setup
             */
            set_page_setup(page_setup: PageSetup): void;
            /**
             * Sets the print settings for the print dialog.
             * @param print_settings the new print settings
             */
            set_print_settings(print_settings: PrintSettings): void;
            /**
             * Sets the title that will be shown on the print dialog.
             * @param title the new title
             */
            set_title(title: string): void;
            /**
             * This function presents a print dialog to let the user select a printer,
             * and set up print settings and page setup.
             *
             * The `callback` will be called when the dialog is dismissed.
             * The obtained [struct`Gtk`.PrintSetup] can then be passed
             * to [method`Gtk`.PrintDialog.print] or [method`Gtk`.PrintDialog.print_file].
             *
             * One possible use for this method is to have the user select a printer,
             * then show a page setup UI in the application (e.g. to arrange images
             * on a page), then call [method`Gtk`.PrintDialog.print] on `self`
             * to do the printing without further user interaction.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             */
            setup(parent?: Window | null, cancellable?: Gio.Cancellable | null): Promise<PrintSetup>;
            /**
             * This function presents a print dialog to let the user select a printer,
             * and set up print settings and page setup.
             *
             * The `callback` will be called when the dialog is dismissed.
             * The obtained [struct`Gtk`.PrintSetup] can then be passed
             * to [method`Gtk`.PrintDialog.print] or [method`Gtk`.PrintDialog.print_file].
             *
             * One possible use for this method is to have the user select a printer,
             * then show a page setup UI in the application (e.g. to arrange images
             * on a page), then call [method`Gtk`.PrintDialog.print] on `self`
             * to do the printing without further user interaction.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            setup(
                parent: Window | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * This function presents a print dialog to let the user select a printer,
             * and set up print settings and page setup.
             *
             * The `callback` will be called when the dialog is dismissed.
             * The obtained [struct`Gtk`.PrintSetup] can then be passed
             * to [method`Gtk`.PrintDialog.print] or [method`Gtk`.PrintDialog.print_file].
             *
             * One possible use for this method is to have the user select a printer,
             * then show a page setup UI in the application (e.g. to arrange images
             * on a page), then call [method`Gtk`.PrintDialog.print] on `self`
             * to do the printing without further user interaction.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            setup(
                parent?: Window | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<PrintSetup> | void;
            /**
             * Finishes the [method`Gtk`.PrintDialog.setup] call.
             *
             * If the call was successful, it returns a [struct`Gtk`.PrintSetup]
             * which contains the print settings and page setup information that
             * will be used to print.
             * @param result a `GAsyncResult`
             * @returns The `GtkPrintSetup` object that resulted from the call,   or `NULL` if the call was not successful
             */
            setup_finish(result: Gio.AsyncResult): PrintSetup;
        }

        namespace PrintJob {
            // Signal callback interfaces

            interface StatusChanged {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                page_setup: PageSetup;
                pageSetup: PageSetup;
                printer: Printer;
                settings: PrintSettings;
                title: string;
                track_print_status: boolean;
                trackPrintStatus: boolean;
            }
        }

        /**
         * A `GtkPrintJob` object represents a job that is sent to a printer.
         *
         * You only need to deal directly with print jobs if you use the
         * non-portable [class`Gtk`.PrintUnixDialog] API.
         *
         * Use [method`Gtk`.PrintJob.get_surface] to obtain the cairo surface
         * onto which the pages must be drawn. Use [method`Gtk`.PrintJob.send]
         * to send the finished job to the printer. If you don’t use cairo
         * `GtkPrintJob` also supports printing of manually generated PostScript,
         * via [method`Gtk`.PrintJob.set_source_file].
         */
        class PrintJob extends GObject.Object {
            static $gtype: GObject.GType<PrintJob>;

            // Properties

            /**
             * Page setup.
             */
            get page_setup(): PageSetup;
            /**
             * Page setup.
             */
            get pageSetup(): PageSetup;
            /**
             * The printer to send the job to.
             */
            get printer(): Printer;
            /**
             * Printer settings.
             */
            get settings(): PrintSettings;
            /**
             * The title of the print job.
             */
            get title(): string;
            /**
             * %TRUE if the print job will continue to emit status-changed
             * signals after the print data has been setn to the printer.
             */
            get track_print_status(): boolean;
            set track_print_status(val: boolean);
            /**
             * %TRUE if the print job will continue to emit status-changed
             * signals after the print data has been setn to the printer.
             */
            get trackPrintStatus(): boolean;
            set trackPrintStatus(val: boolean);

            // Constructors

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

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

            static ['new'](title: string, printer: Printer, settings: PrintSettings, page_setup: PageSetup): PrintJob;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'status-changed', callback: (_source: this) => void): number;
            connect_after(signal: 'status-changed', callback: (_source: this) => void): number;
            emit(signal: 'status-changed'): void;

            // Methods

            /**
             * Gets whether this job is printed collated.
             * @returns whether the job is printed collated
             */
            get_collate(): boolean;
            /**
             * Gets the n-up setting for this job.
             * @returns the n-up setting
             */
            get_n_up(): number;
            /**
             * Gets the n-up layout setting for this job.
             * @returns the n-up layout
             */
            get_n_up_layout(): NumberUpLayout;
            /**
             * Gets the number of copies of this job.
             * @returns the number of copies
             */
            get_num_copies(): number;
            /**
             * Gets the page ranges for this job.
             * @returns a pointer to an   array of `GtkPageRange` structs
             */
            get_page_ranges(): PageRange[];
            /**
             * Gets the `GtkPageSet` setting for this job.
             * @returns the `GtkPageSet` setting
             */
            get_page_set(): PageSet;
            /**
             * Gets the `GtkPrintPages` setting for this job.
             * @returns the `GtkPrintPages` setting
             */
            get_pages(): PrintPages;
            /**
             * Gets the `GtkPrinter` of the print job.
             * @returns the printer of @job
             */
            get_printer(): Printer;
            /**
             * Gets whether this job is printed reversed.
             * @returns whether the job is printed reversed.
             */
            get_reverse(): boolean;
            /**
             * Gets whether the job is printed rotated.
             * @returns whether the job is printed rotated
             */
            get_rotate(): boolean;
            /**
             * Gets the scale for this job.
             * @returns the scale
             */
            get_scale(): number;
            /**
             * Gets the `GtkPrintSettings` of the print job.
             * @returns the settings of @job
             */
            get_settings(): PrintSettings;
            /**
             * Gets the status of the print job.
             * @returns the status of @job
             */
            get_status(): PrintStatus;
            /**
             * Gets a cairo surface onto which the pages of
             * the print job should be rendered.
             * @returns the cairo surface of @job
             */
            get_surface(): cairo.Surface;
            /**
             * Gets the job title.
             * @returns the title of @job
             */
            get_title(): string;
            /**
             * Returns whether jobs will be tracked after printing.
             *
             * For details, see [method`Gtk`.PrintJob.set_track_print_status].
             * @returns %TRUE if print job status will be reported after printing
             */
            get_track_print_status(): boolean;
            /**
             * Sends the print job off to the printer.
             * @param callback function   to call when the job completes or an error occurs
             */
            send(callback: PrintJobCompleteFunc): void;
            /**
             * Sets whether this job is printed collated.
             * @param collate whether the job is printed collated
             */
            set_collate(collate: boolean): void;
            /**
             * Sets the n-up setting for this job.
             * @param n_up the n-up value
             */
            set_n_up(n_up: number): void;
            /**
             * Sets the n-up layout setting for this job.
             * @param layout the n-up layout setting
             */
            set_n_up_layout(layout: NumberUpLayout | null): void;
            /**
             * Sets the number of copies for this job.
             * @param num_copies the number of copies
             */
            set_num_copies(num_copies: number): void;
            /**
             * Sets the page ranges for this job.
             * @param ranges pointer to an array of    `GtkPageRange` structs
             */
            set_page_ranges(ranges: PageRange[]): void;
            /**
             * Sets the `GtkPageSet` setting for this job.
             * @param page_set a `GtkPageSet` setting
             */
            set_page_set(page_set: PageSet | null): void;
            /**
             * Sets the `GtkPrintPages` setting for this job.
             * @param pages the `GtkPrintPages` setting
             */
            set_pages(pages: PrintPages | null): void;
            /**
             * Sets whether this job is printed reversed.
             * @param reverse whether the job is printed reversed
             */
            set_reverse(reverse: boolean): void;
            /**
             * Sets whether this job is printed rotated.
             * @param rotate whether to print rotated
             */
            set_rotate(rotate: boolean): void;
            /**
             * Sets the scale for this job.
             *
             * 1.0 means unscaled.
             * @param scale the scale
             */
            set_scale(scale: number): void;
            /**
             * Make the `GtkPrintJob` send an existing document to the
             * printing system.
             *
             * The file can be in any format understood by the platforms
             * printing system (typically PostScript, but on many platforms
             * PDF may work too). See [method`Gtk`.Printer.accepts_pdf] and
             * [method`Gtk`.Printer.accepts_ps].
             *
             * This is similar to [method`Gtk`.PrintJob.set_source_file],
             * but takes expects an open file descriptor for the file,
             * instead of a filename.
             * @param fd a file descriptor
             * @returns %FALSE if an error occurred
             */
            set_source_fd(fd: number): boolean;
            /**
             * Make the `GtkPrintJob` send an existing document to the
             * printing system.
             *
             * The file can be in any format understood by the platforms
             * printing system (typically PostScript, but on many platforms
             * PDF may work too). See [method`Gtk`.Printer.accepts_pdf] and
             * [method`Gtk`.Printer.accepts_ps].
             * @param filename the file to be printed
             * @returns %FALSE if an error occurred
             */
            set_source_file(filename: string): boolean;
            /**
             * If track_status is %TRUE, the print job will try to continue report
             * on the status of the print job in the printer queues and printer.
             *
             * This can allow your application to show things like “out of paper”
             * issues, and when the print job actually reaches the printer.
             *
             * This function is often implemented using some form of polling,
             * so it should not be enabled unless needed.
             * @param track_status %TRUE to track status after printing
             */
            set_track_print_status(track_status: boolean): void;
        }

        namespace PrintOperation {
            // Signal callback interfaces

            interface BeginPrint {
                (context: PrintContext): void;
            }

            interface CreateCustomWidget {
                (): GObject.Object | null;
            }

            interface CustomWidgetApply {
                (widget: Widget): void;
            }

            interface Done {
                (result: PrintOperationResult): void;
            }

            interface DrawPage {
                (context: PrintContext, page_nr: number): void;
            }

            interface EndPrint {
                (context: PrintContext): void;
            }

            interface Paginate {
                (context: PrintContext): boolean;
            }

            interface Preview {
                (preview: PrintOperationPreview, context: PrintContext, parent?: Window | null): boolean;
            }

            interface RequestPageSetup {
                (context: PrintContext, page_nr: number, setup: PageSetup): void;
            }

            interface StatusChanged {
                (): void;
            }

            interface UpdateCustomWidget {
                (widget: Widget, setup: PageSetup, settings: PrintSettings): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps, PrintOperationPreview.ConstructorProps {
                allow_async: boolean;
                allowAsync: boolean;
                current_page: number;
                currentPage: number;
                custom_tab_label: string;
                customTabLabel: string;
                default_page_setup: PageSetup;
                defaultPageSetup: PageSetup;
                embed_page_setup: boolean;
                embedPageSetup: boolean;
                export_filename: string;
                exportFilename: string;
                has_selection: boolean;
                hasSelection: boolean;
                job_name: string;
                jobName: string;
                n_pages: number;
                nPages: number;
                n_pages_to_print: number;
                nPagesToPrint: number;
                print_settings: PrintSettings;
                printSettings: PrintSettings;
                show_progress: boolean;
                showProgress: boolean;
                status: PrintStatus;
                status_string: string;
                statusString: string;
                support_selection: boolean;
                supportSelection: boolean;
                track_print_status: boolean;
                trackPrintStatus: boolean;
                unit: Unit;
                use_full_page: boolean;
                useFullPage: boolean;
            }
        }

        /**
         * `GtkPrintOperation` is the high-level, portable printing API.
         *
         * It looks a bit different than other GTK dialogs such as the
         * `GtkFileChooser`, since some platforms don’t expose enough
         * infrastructure to implement a good print dialog. On such
         * platforms, `GtkPrintOperation` uses the native print dialog.
         * On platforms which do not provide a native print dialog, GTK
         * uses its own, see [class`Gtk`.PrintUnixDialog].
         *
         * The typical way to use the high-level printing API is to create
         * a `GtkPrintOperation` object with [ctor`Gtk`.PrintOperation.new]
         * when the user selects to print. Then you set some properties on it,
         * e.g. the page size, any [class`Gtk`.PrintSettings] from previous print
         * operations, the number of pages, the current page, etc.
         *
         * Then you start the print operation by calling [method`Gtk`.PrintOperation.run].
         * It will then show a dialog, let the user select a printer and options.
         * When the user finished the dialog, various signals will be emitted on
         * the `GtkPrintOperation`, the main one being
         * [signal`Gtk`.PrintOperation::draw-page], which you are supposed to handle
         * and render the page on the provided [class`Gtk`.PrintContext] using Cairo.
         *
         * # The high-level printing API
         *
         * ```c
         * static GtkPrintSettings *settings = NULL;
         *
         * static void
         * do_print (void)
         * {
         *   GtkPrintOperation *print;
         *   GtkPrintOperationResult res;
         *
         *   print = gtk_print_operation_new ();
         *
         *   if (settings != NULL)
         *     gtk_print_operation_set_print_settings (print, settings);
         *
         *   g_signal_connect (print, "begin_print", G_CALLBACK (begin_print), NULL);
         *   g_signal_connect (print, "draw_page", G_CALLBACK (draw_page), NULL);
         *
         *   res = gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
         *                                  GTK_WINDOW (main_window), NULL);
         *
         *   if (res == GTK_PRINT_OPERATION_RESULT_APPLY)
         *     {
         *       if (settings != NULL)
         *         g_object_unref (settings);
         *       settings = g_object_ref (gtk_print_operation_get_print_settings (print));
         *     }
         *
         *   g_object_unref (print);
         * }
         * ```
         *
         * By default `GtkPrintOperation` uses an external application to do
         * print preview. To implement a custom print preview, an application
         * must connect to the preview signal. The functions
         * [method`Gtk`.PrintOperationPreview.render_page],
         * [method`Gtk`.PrintOperationPreview.end_preview] and
         * [method`Gtk`.PrintOperationPreview.is_selected]
         * are useful when implementing a print preview.
         */
        class PrintOperation extends GObject.Object implements PrintOperationPreview {
            static $gtype: GObject.GType<PrintOperation>;

            // Properties

            /**
             * Determines whether the print operation may run asynchronously or not.
             *
             * Some systems don't support asynchronous printing, but those that do
             * will return %GTK_PRINT_OPERATION_RESULT_IN_PROGRESS as the status, and
             * emit the [signal`Gtk`.PrintOperation::done] signal when the operation
             * is actually done.
             *
             * The Windows port does not support asynchronous operation at all (this
             * is unlikely to change). On other platforms, all actions except for
             * %GTK_PRINT_OPERATION_ACTION_EXPORT support asynchronous operation.
             */
            get allow_async(): boolean;
            set allow_async(val: boolean);
            /**
             * Determines whether the print operation may run asynchronously or not.
             *
             * Some systems don't support asynchronous printing, but those that do
             * will return %GTK_PRINT_OPERATION_RESULT_IN_PROGRESS as the status, and
             * emit the [signal`Gtk`.PrintOperation::done] signal when the operation
             * is actually done.
             *
             * The Windows port does not support asynchronous operation at all (this
             * is unlikely to change). On other platforms, all actions except for
             * %GTK_PRINT_OPERATION_ACTION_EXPORT support asynchronous operation.
             */
            get allowAsync(): boolean;
            set allowAsync(val: boolean);
            /**
             * The current page in the document.
             *
             * If this is set before [method`Gtk`.PrintOperation.run],
             * the user will be able to select to print only the current page.
             *
             * Note that this only makes sense for pre-paginated documents.
             */
            get current_page(): number;
            set current_page(val: number);
            /**
             * The current page in the document.
             *
             * If this is set before [method`Gtk`.PrintOperation.run],
             * the user will be able to select to print only the current page.
             *
             * Note that this only makes sense for pre-paginated documents.
             */
            get currentPage(): number;
            set currentPage(val: number);
            /**
             * Used as the label of the tab containing custom widgets.
             *
             * Note that this property may be ignored on some platforms.
             *
             * If this is %NULL, GTK uses a default label.
             */
            get custom_tab_label(): string;
            set custom_tab_label(val: string);
            /**
             * Used as the label of the tab containing custom widgets.
             *
             * Note that this property may be ignored on some platforms.
             *
             * If this is %NULL, GTK uses a default label.
             */
            get customTabLabel(): string;
            set customTabLabel(val: string);
            /**
             * The `GtkPageSetup` used by default.
             *
             * This page setup will be used by [method`Gtk`.PrintOperation.run],
             * but it can be overridden on a per-page basis by connecting
             * to the [signal`Gtk`.PrintOperation::request-page-setup] signal.
             */
            get default_page_setup(): PageSetup;
            set default_page_setup(val: PageSetup);
            /**
             * The `GtkPageSetup` used by default.
             *
             * This page setup will be used by [method`Gtk`.PrintOperation.run],
             * but it can be overridden on a per-page basis by connecting
             * to the [signal`Gtk`.PrintOperation::request-page-setup] signal.
             */
            get defaultPageSetup(): PageSetup;
            set defaultPageSetup(val: PageSetup);
            /**
             * If %TRUE, page size combo box and orientation combo box
             * are embedded into page setup page.
             */
            get embed_page_setup(): boolean;
            set embed_page_setup(val: boolean);
            /**
             * If %TRUE, page size combo box and orientation combo box
             * are embedded into page setup page.
             */
            get embedPageSetup(): boolean;
            set embedPageSetup(val: boolean);
            /**
             * The name of a file to generate instead of showing the print dialog.
             *
             * Currently, PDF is the only supported format.
             *
             * The intended use of this property is for implementing
             * “Export to PDF” actions.
             *
             * “Print to PDF” support is independent of this and is done
             * by letting the user pick the “Print to PDF” item from the
             * list of printers in the print dialog.
             */
            get export_filename(): string;
            set export_filename(val: string);
            /**
             * The name of a file to generate instead of showing the print dialog.
             *
             * Currently, PDF is the only supported format.
             *
             * The intended use of this property is for implementing
             * “Export to PDF” actions.
             *
             * “Print to PDF” support is independent of this and is done
             * by letting the user pick the “Print to PDF” item from the
             * list of printers in the print dialog.
             */
            get exportFilename(): string;
            set exportFilename(val: string);
            /**
             * Determines whether there is a selection in your application.
             *
             * This can allow your application to print the selection.
             * This is typically used to make a "Selection" button sensitive.
             */
            get has_selection(): boolean;
            set has_selection(val: boolean);
            /**
             * Determines whether there is a selection in your application.
             *
             * This can allow your application to print the selection.
             * This is typically used to make a "Selection" button sensitive.
             */
            get hasSelection(): boolean;
            set hasSelection(val: boolean);
            /**
             * A string used to identify the job (e.g. in monitoring
             * applications like eggcups).
             *
             * If you don't set a job name, GTK picks a default one
             * by numbering successive print jobs.
             */
            get job_name(): string;
            set job_name(val: string);
            /**
             * A string used to identify the job (e.g. in monitoring
             * applications like eggcups).
             *
             * If you don't set a job name, GTK picks a default one
             * by numbering successive print jobs.
             */
            get jobName(): string;
            set jobName(val: string);
            /**
             * The number of pages in the document.
             *
             * This must be set to a positive number before the rendering
             * starts. It may be set in a [signal`Gtk`.PrintOperation::begin-print]
             * signal handler.
             *
             * Note that the page numbers passed to the
             * [signal`Gtk`.PrintOperation::request-page-setup] and
             * [signal`Gtk`.PrintOperation::draw-page] signals are 0-based, i.e.
             * if the user chooses to print all pages, the last ::draw-page signal
             * will be for page `n_pages` - 1.
             */
            get n_pages(): number;
            set n_pages(val: number);
            /**
             * The number of pages in the document.
             *
             * This must be set to a positive number before the rendering
             * starts. It may be set in a [signal`Gtk`.PrintOperation::begin-print]
             * signal handler.
             *
             * Note that the page numbers passed to the
             * [signal`Gtk`.PrintOperation::request-page-setup] and
             * [signal`Gtk`.PrintOperation::draw-page] signals are 0-based, i.e.
             * if the user chooses to print all pages, the last ::draw-page signal
             * will be for page `n_pages` - 1.
             */
            get nPages(): number;
            set nPages(val: number);
            /**
             * The number of pages that will be printed.
             *
             * Note that this value is set during print preparation phase
             * (%GTK_PRINT_STATUS_PREPARING), so this value should never be
             * get before the data generation phase (%GTK_PRINT_STATUS_GENERATING_DATA).
             * You can connect to the [signal`Gtk`.PrintOperation::status-changed] signal
             * and call [method`Gtk`.PrintOperation.get_n_pages_to_print] when
             * print status is %GTK_PRINT_STATUS_GENERATING_DATA.
             *
             * This is typically used to track the progress of print operation.
             */
            get n_pages_to_print(): number;
            /**
             * The number of pages that will be printed.
             *
             * Note that this value is set during print preparation phase
             * (%GTK_PRINT_STATUS_PREPARING), so this value should never be
             * get before the data generation phase (%GTK_PRINT_STATUS_GENERATING_DATA).
             * You can connect to the [signal`Gtk`.PrintOperation::status-changed] signal
             * and call [method`Gtk`.PrintOperation.get_n_pages_to_print] when
             * print status is %GTK_PRINT_STATUS_GENERATING_DATA.
             *
             * This is typically used to track the progress of print operation.
             */
            get nPagesToPrint(): number;
            /**
             * The `GtkPrintSettings` used for initializing the dialog.
             *
             * Setting this property is typically used to re-establish
             * print settings from a previous print operation, see
             * [method`Gtk`.PrintOperation.run].
             */
            get print_settings(): PrintSettings;
            set print_settings(val: PrintSettings);
            /**
             * The `GtkPrintSettings` used for initializing the dialog.
             *
             * Setting this property is typically used to re-establish
             * print settings from a previous print operation, see
             * [method`Gtk`.PrintOperation.run].
             */
            get printSettings(): PrintSettings;
            set printSettings(val: PrintSettings);
            /**
             * Determines whether to show a progress dialog during the
             * print operation.
             */
            get show_progress(): boolean;
            set show_progress(val: boolean);
            /**
             * Determines whether to show a progress dialog during the
             * print operation.
             */
            get showProgress(): boolean;
            set showProgress(val: boolean);
            /**
             * The status of the print operation.
             */
            get status(): PrintStatus;
            /**
             * A string representation of the status of the print operation.
             *
             * The string is translated and suitable for displaying the print
             * status e.g. in a `GtkStatusbar`.
             *
             * See the [property`Gtk`.PrintOperation:status] property for a status
             * value that is suitable for programmatic use.
             */
            get status_string(): string;
            /**
             * A string representation of the status of the print operation.
             *
             * The string is translated and suitable for displaying the print
             * status e.g. in a `GtkStatusbar`.
             *
             * See the [property`Gtk`.PrintOperation:status] property for a status
             * value that is suitable for programmatic use.
             */
            get statusString(): string;
            /**
             * If %TRUE, the print operation will support print of selection.
             *
             * This allows the print dialog to show a "Selection" button.
             */
            get support_selection(): boolean;
            set support_selection(val: boolean);
            /**
             * If %TRUE, the print operation will support print of selection.
             *
             * This allows the print dialog to show a "Selection" button.
             */
            get supportSelection(): boolean;
            set supportSelection(val: boolean);
            /**
             * If %TRUE, the print operation will try to continue report on
             * the status of the print job in the printer queues and printer.
             *
             * This can allow your application to show things like “out of paper”
             * issues, and when the print job actually reaches the printer.
             * However, this is often implemented using polling, and should
             * not be enabled unless needed.
             */
            get track_print_status(): boolean;
            set track_print_status(val: boolean);
            /**
             * If %TRUE, the print operation will try to continue report on
             * the status of the print job in the printer queues and printer.
             *
             * This can allow your application to show things like “out of paper”
             * issues, and when the print job actually reaches the printer.
             * However, this is often implemented using polling, and should
             * not be enabled unless needed.
             */
            get trackPrintStatus(): boolean;
            set trackPrintStatus(val: boolean);
            /**
             * The transformation for the cairo context obtained from
             * `GtkPrintContext` is set up in such a way that distances
             * are measured in units of `unit`.
             */
            get unit(): Unit;
            set unit(val: Unit);
            /**
             * If %TRUE, the transformation for the cairo context obtained
             * from `GtkPrintContext` puts the origin at the top left corner
             * of the page.
             *
             * This may not be the top left corner of the sheet, depending on
             * page orientation and the number of pages per sheet. Otherwise,
             * the origin is at the top left corner of the imageable area (i.e.
             * inside the margins).
             */
            get use_full_page(): boolean;
            set use_full_page(val: boolean);
            /**
             * If %TRUE, the transformation for the cairo context obtained
             * from `GtkPrintContext` puts the origin at the top left corner
             * of the page.
             *
             * This may not be the top left corner of the sheet, depending on
             * page orientation and the number of pages per sheet. Otherwise,
             * the origin is at the top left corner of the imageable area (i.e.
             * inside the margins).
             */
            get useFullPage(): boolean;
            set useFullPage(val: boolean);

            // Constructors

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

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

            static ['new'](): PrintOperation;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'begin-print', callback: (_source: this, context: PrintContext) => void): number;
            connect_after(signal: 'begin-print', callback: (_source: this, context: PrintContext) => void): number;
            emit(signal: 'begin-print', context: PrintContext): void;
            connect(signal: 'create-custom-widget', callback: (_source: this) => GObject.Object | null): number;
            connect_after(signal: 'create-custom-widget', callback: (_source: this) => GObject.Object | null): number;
            emit(signal: 'create-custom-widget'): void;
            connect(signal: 'custom-widget-apply', callback: (_source: this, widget: Widget) => void): number;
            connect_after(signal: 'custom-widget-apply', callback: (_source: this, widget: Widget) => void): number;
            emit(signal: 'custom-widget-apply', widget: Widget): void;
            connect(signal: 'done', callback: (_source: this, result: PrintOperationResult) => void): number;
            connect_after(signal: 'done', callback: (_source: this, result: PrintOperationResult) => void): number;
            emit(signal: 'done', result: PrintOperationResult): void;
            connect(
                signal: 'draw-page',
                callback: (_source: this, context: PrintContext, page_nr: number) => void,
            ): number;
            connect_after(
                signal: 'draw-page',
                callback: (_source: this, context: PrintContext, page_nr: number) => void,
            ): number;
            emit(signal: 'draw-page', context: PrintContext, page_nr: number): void;
            connect(signal: 'end-print', callback: (_source: this, context: PrintContext) => void): number;
            connect_after(signal: 'end-print', callback: (_source: this, context: PrintContext) => void): number;
            emit(signal: 'end-print', context: PrintContext): void;
            connect(signal: 'paginate', callback: (_source: this, context: PrintContext) => boolean): number;
            connect_after(signal: 'paginate', callback: (_source: this, context: PrintContext) => boolean): number;
            emit(signal: 'paginate', context: PrintContext): void;
            connect(
                signal: 'preview',
                callback: (
                    _source: this,
                    preview: PrintOperationPreview,
                    context: PrintContext,
                    parent: Window | null,
                ) => boolean,
            ): number;
            connect_after(
                signal: 'preview',
                callback: (
                    _source: this,
                    preview: PrintOperationPreview,
                    context: PrintContext,
                    parent: Window | null,
                ) => boolean,
            ): number;
            emit(
                signal: 'preview',
                preview: PrintOperationPreview,
                context: PrintContext,
                parent?: Window | null,
            ): void;
            connect(
                signal: 'request-page-setup',
                callback: (_source: this, context: PrintContext, page_nr: number, setup: PageSetup) => void,
            ): number;
            connect_after(
                signal: 'request-page-setup',
                callback: (_source: this, context: PrintContext, page_nr: number, setup: PageSetup) => void,
            ): number;
            emit(signal: 'request-page-setup', context: PrintContext, page_nr: number, setup: PageSetup): void;
            connect(signal: 'status-changed', callback: (_source: this) => void): number;
            connect_after(signal: 'status-changed', callback: (_source: this) => void): number;
            emit(signal: 'status-changed'): void;
            connect(
                signal: 'update-custom-widget',
                callback: (_source: this, widget: Widget, setup: PageSetup, settings: PrintSettings) => void,
            ): number;
            connect_after(
                signal: 'update-custom-widget',
                callback: (_source: this, widget: Widget, setup: PageSetup, settings: PrintSettings) => void,
            ): number;
            emit(signal: 'update-custom-widget', widget: Widget, setup: PageSetup, settings: PrintSettings): void;

            // Virtual methods

            /**
             * Signal emitted after the user has finished changing
             *    print settings in the dialog, before the actual rendering starts.
             * @param context
             */
            vfunc_begin_print(context: PrintContext): void;
            /**
             * Signal emitted right before “begin-print” if
             *    you added a custom widget in the “create-custom-widget” handler.
             * @param widget
             */
            vfunc_custom_widget_apply(widget: Widget): void;
            /**
             * Signal emitted when the print operation run has finished
             *    doing everything required for printing.
             * @param result
             */
            vfunc_done(result: PrintOperationResult): void;
            /**
             * Signal emitted for every page that is printed.
             * @param context
             * @param page_nr
             */
            vfunc_draw_page(context: PrintContext, page_nr: number): void;
            /**
             * Signal emitted after all pages have been rendered.
             * @param context
             */
            vfunc_end_print(context: PrintContext): void;
            /**
             * Signal emitted after the “begin-print” signal, but
             *    before the actual rendering starts.
             * @param context
             */
            vfunc_paginate(context: PrintContext): boolean;
            /**
             * Signal emitted when a preview is requested from the
             *    native dialog.
             * @param preview
             * @param context
             * @param parent
             */
            vfunc_preview(preview: PrintOperationPreview, context: PrintContext, parent: Window): boolean;
            /**
             * Emitted once for every page that is printed,
             *    to give the application a chance to modify the page setup.
             * @param context
             * @param page_nr
             * @param setup
             */
            vfunc_request_page_setup(context: PrintContext, page_nr: number, setup: PageSetup): void;
            /**
             * Emitted at between the various phases of the print
             *    operation.
             */
            vfunc_status_changed(): void;
            /**
             * Emitted after change of selected printer.
             * @param widget
             * @param setup
             * @param settings
             */
            vfunc_update_custom_widget(widget: Widget, setup: PageSetup, settings: PrintSettings): void;

            // Methods

            /**
             * Cancels a running print operation.
             *
             * This function may be called from a [signal`Gtk`.PrintOperation::begin-print],
             * [signal`Gtk`.PrintOperation::paginate] or [signal`Gtk`.PrintOperation::draw-page]
             * signal handler to stop the currently running print operation.
             */
            cancel(): void;
            /**
             * Signal that drawing of particular page is complete.
             *
             * It is called after completion of page drawing (e.g. drawing
             * in another thread). If [method`Gtk`.PrintOperation.set_defer_drawing]
             * was called before, then this function has to be called by application.
             * Otherwise it is called by GTK itself.
             */
            draw_page_finish(): void;
            /**
             * Returns the default page setup.
             * @returns the default page setup
             */
            get_default_page_setup(): PageSetup;
            /**
             * Gets whether page setup selection combos are embedded
             * @returns whether page setup selection combos are embedded
             */
            get_embed_page_setup(): boolean;
            /**
             * Call this when the result of a print operation is
             * %GTK_PRINT_OPERATION_RESULT_ERROR.
             *
             * It can be called either after [method`Gtk`.PrintOperation.run]
             * returns, or in the [signal`Gtk`.PrintOperation::done] signal
             * handler.
             *
             * The returned `GError` will contain more details on what went wrong.
             */
            get_error(): void;
            /**
             * Gets whether there is a selection.
             * @returns whether there is a selection
             */
            get_has_selection(): boolean;
            /**
             * Returns the number of pages that will be printed.
             *
             * Note that this value is set during print preparation phase
             * (%GTK_PRINT_STATUS_PREPARING), so this function should never be
             * called before the data generation phase (%GTK_PRINT_STATUS_GENERATING_DATA).
             * You can connect to the [signal`Gtk`.PrintOperation::status-changed]
             * signal and call gtk_print_operation_get_n_pages_to_print() when
             * print status is %GTK_PRINT_STATUS_GENERATING_DATA.
             *
             * This is typically used to track the progress of print operation.
             * @returns the number of pages that will be printed
             */
            get_n_pages_to_print(): number;
            /**
             * Returns the current print settings.
             *
             * Note that the return value is %NULL until either
             * [method`Gtk`.PrintOperation.set_print_settings] or
             * [method`Gtk`.PrintOperation.run] have been called.
             * @returns the current print settings of @op.
             */
            get_print_settings(): PrintSettings | null;
            /**
             * Returns the status of the print operation.
             *
             * Also see [method`Gtk`.PrintOperation.get_status_string].
             * @returns the status of the print operation
             */
            get_status(): PrintStatus;
            /**
             * Returns a string representation of the status of the
             * print operation.
             *
             * The string is translated and suitable for displaying
             * the print status e.g. in a `GtkStatusbar`.
             *
             * Use [method`Gtk`.PrintOperation.get_status] to obtain
             * a status value that is suitable for programmatic use.
             * @returns a string representation of the status    of the print operation
             */
            get_status_string(): string;
            /**
             * Gets whether the application supports print of selection
             * @returns whether the application supports print of selection
             */
            get_support_selection(): boolean;
            /**
             * A convenience function to find out if the print operation
             * is finished.
             *
             * a print operation is finished if its status is either
             * %GTK_PRINT_STATUS_FINISHED or %GTK_PRINT_STATUS_FINISHED_ABORTED.
             *
             * Note: when you enable print status tracking the print operation
             * can be in a non-finished state even after done has been called, as
             * the operation status then tracks the print job status on the printer.
             * @returns %TRUE, if the print operation is finished.
             */
            is_finished(): boolean;
            /**
             * Runs the print operation.
             *
             * Normally that this function does not return until the rendering
             * of all pages is complete. You can connect to the
             * [signal`Gtk`.PrintOperation::status-changed] signal on `op` to obtain
             * some information about the progress of the print operation.
             *
             * Furthermore, it may use a recursive mainloop to show the print dialog.
             *
             * If you set the [Gtk.PrintOperation:allow-async] property, the operation
             * will run asynchronously if this is supported on the platform. The
             * [signal`Gtk`.PrintOperation::done] signal will be emitted with the result
             * of the operation when the it is done (i.e. when the dialog is canceled,
             * or when the print succeeds or fails).
             *
             * ```c
             * if (settings != NULL)
             *   gtk_print_operation_set_print_settings (print, settings);
             *
             * if (page_setup != NULL)
             *   gtk_print_operation_set_default_page_setup (print, page_setup);
             *
             * g_signal_connect (print, "begin-print",
             *                   G_CALLBACK (begin_print), &data);
             * g_signal_connect (print, "draw-page",
             *                   G_CALLBACK (draw_page), &data);
             *
             * res = gtk_print_operation_run (print,
             *                                GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
             *                                parent,
             *                                &error);
             *
             * if (res == GTK_PRINT_OPERATION_RESULT_ERROR)
             *  {
             *    error_dialog = gtk_message_dialog_new (GTK_WINDOW (parent),
             *   			                     GTK_DIALOG_DESTROY_WITH_PARENT,
             * 					     GTK_MESSAGE_ERROR,
             * 					     GTK_BUTTONS_CLOSE,
             * 					     "Error printing file:\n%s",
             * 					     error->message);
             *    g_signal_connect (error_dialog, "response",
             *                      G_CALLBACK (gtk_window_destroy), NULL);
             *    gtk_window_present (GTK_WINDOW (error_dialog));
             *    g_error_free (error);
             *  }
             * else if (res == GTK_PRINT_OPERATION_RESULT_APPLY)
             *  {
             *    if (settings != NULL)
             * g_object_unref (settings);
             *    settings = g_object_ref (gtk_print_operation_get_print_settings (print));
             *  }
             * ```
             *
             * Note that gtk_print_operation_run() can only be called once on a
             * given `GtkPrintOperation`.
             * @param action the action to start
             * @param parent Transient parent of the dialog
             * @returns the result of the print operation. A return value of   %GTK_PRINT_OPERATION_RESULT_APPLY indicates that the printing was   completed successfully. In this case, it is a good idea to obtain   the used print settings with   [method@Gtk.PrintOperation.get_print_settings]   and store them for reuse with the next print operation. A value of   %GTK_PRINT_OPERATION_RESULT_IN_PROGRESS means the operation is running   asynchronously, and will emit the [signal@Gtk.PrintOperation::done]   signal when done.
             */
            run(action: PrintOperationAction | null, parent?: Window | null): PrintOperationResult;
            /**
             * Sets whether gtk_print_operation_run() may return
             * before the print operation is completed.
             *
             * Note that some platforms may not allow asynchronous
             * operation.
             * @param allow_async %TRUE to allow asynchronous operation
             */
            set_allow_async(allow_async: boolean): void;
            /**
             * Sets the current page.
             *
             * If this is called before [method`Gtk`.PrintOperation.run],
             * the user will be able to select to print only the current page.
             *
             * Note that this only makes sense for pre-paginated documents.
             * @param current_page the current page, 0-based
             */
            set_current_page(current_page: number): void;
            /**
             * Sets the label for the tab holding custom widgets.
             * @param label the label to use, or %NULL to use the default label
             */
            set_custom_tab_label(label?: string | null): void;
            /**
             * Makes `default_page_setup` the default page setup for `op`.
             *
             * This page setup will be used by [method`Gtk`.PrintOperation.run],
             * but it can be overridden on a per-page basis by connecting
             * to the [signal`Gtk`.PrintOperation::request-page-setup] signal.
             * @param default_page_setup a `GtkPageSetup`
             */
            set_default_page_setup(default_page_setup?: PageSetup | null): void;
            /**
             * Sets up the `GtkPrintOperation` to wait for calling of
             * [method`Gtk`.PrintOperation.draw_page_finish from application.
             *
             * This can be used for drawing page in another thread.
             *
             * This function must be called in the callback of the
             * [signal`Gtk`.PrintOperation::draw-page] signal.
             */
            set_defer_drawing(): void;
            /**
             * Embed page size combo box and orientation combo box into page setup page.
             *
             * Selected page setup is stored as default page setup in `GtkPrintOperation`.
             * @param embed %TRUE to embed page setup selection in the `GtkPrintUnixDialog`
             */
            set_embed_page_setup(embed: boolean): void;
            /**
             * Sets up the `GtkPrintOperation` to generate a file instead
             * of showing the print dialog.
             *
             * The intended use of this function is for implementing
             * “Export to PDF” actions. Currently, PDF is the only supported
             * format.
             *
             * “Print to PDF” support is independent of this and is done
             * by letting the user pick the “Print to PDF” item from the list
             * of printers in the print dialog.
             * @param filename the filename for the exported file
             */
            set_export_filename(filename: string): void;
            /**
             * Sets whether there is a selection to print.
             *
             * Application has to set number of pages to which the selection
             * will draw by [method`Gtk`.PrintOperation.set_n_pages] in a handler
             * for the [signal`Gtk`.PrintOperation::begin-print] signal.
             * @param has_selection %TRUE indicates that a selection exists
             */
            set_has_selection(has_selection: boolean): void;
            /**
             * Sets the name of the print job.
             *
             * The name is used to identify the job (e.g. in monitoring
             * applications like eggcups).
             *
             * If you don’t set a job name, GTK picks a default one by
             * numbering successive print jobs.
             * @param job_name a string that identifies the print job
             */
            set_job_name(job_name: string): void;
            /**
             * Sets the number of pages in the document.
             *
             * This must be set to a positive number before the rendering
             * starts. It may be set in a [signal`Gtk`.PrintOperation::begin-print]
             * signal handler.
             *
             * Note that the page numbers passed to the
             * [signal`Gtk`.PrintOperation::request-page-setup]
             * and [signal`Gtk`.PrintOperation::draw-page] signals are 0-based, i.e.
             * if the user chooses to print all pages, the last ::draw-page signal
             * will be for page `n_pages` - 1.
             * @param n_pages the number of pages
             */
            set_n_pages(n_pages: number): void;
            /**
             * Sets the print settings for `op`.
             *
             * This is typically used to re-establish print settings
             * from a previous print operation, see [method`Gtk`.PrintOperation.run].
             * @param print_settings `GtkPrintSettings`
             */
            set_print_settings(print_settings?: PrintSettings | null): void;
            /**
             * If `show_progress` is %TRUE, the print operation will show
             * a progress dialog during the print operation.
             * @param show_progress %TRUE to show a progress dialog
             */
            set_show_progress(show_progress: boolean): void;
            /**
             * Sets whether selection is supported by `GtkPrintOperation`.
             * @param support_selection %TRUE to support selection
             */
            set_support_selection(support_selection: boolean): void;
            /**
             * If track_status is %TRUE, the print operation will try to continue
             * report on the status of the print job in the printer queues and printer.
             *
             * This can allow your application to show things like “out of paper”
             * issues, and when the print job actually reaches the printer.
             *
             * This function is often implemented using some form of polling,
             * so it should not be enabled unless needed.
             * @param track_status %TRUE to track status after printing
             */
            set_track_print_status(track_status: boolean): void;
            /**
             * Sets up the transformation for the cairo context obtained from
             * `GtkPrintContext` in such a way that distances are measured in
             * units of `unit`.
             * @param unit the unit to use
             */
            set_unit(unit: Unit | null): void;
            /**
             * If `full_page` is %TRUE, the transformation for the cairo context
             * obtained from `GtkPrintContext` puts the origin at the top left
             * corner of the page.
             *
             * This may not be the top left corner of the sheet, depending on page
             * orientation and the number of pages per sheet). Otherwise, the origin
             * is at the top left corner of the imageable area (i.e. inside the margins).
             * @param full_page %TRUE to set up the `GtkPrintContext` for the full page
             */
            set_use_full_page(full_page: boolean): void;

            // Inherited methods
            /**
             * Ends a preview.
             *
             * This function must be called to finish a custom print preview.
             */
            end_preview(): void;
            /**
             * Returns whether the given page is included in the set of pages that
             * have been selected for printing.
             * @param page_nr a page number
             * @returns %TRUE if the page has been selected for printing
             */
            is_selected(page_nr: number): boolean;
            /**
             * Renders a page to the preview.
             *
             * This is using the print context that was passed to the
             * [signal`Gtk`.PrintOperation::preview] handler together
             * with `preview`.
             *
             * A custom print preview should use this function to render
             * the currently selected page.
             *
             * Note that this function requires a suitable cairo context to
             * be associated with the print context.
             * @param page_nr the page to render
             */
            render_page(page_nr: number): void;
            /**
             * Ends a preview.
             *
             * This function must be called to finish a custom print preview.
             */
            vfunc_end_preview(): void;
            vfunc_got_page_size(context: PrintContext, page_setup: PageSetup): void;
            /**
             * Returns whether the given page is included in the set of pages that
             * have been selected for printing.
             * @param page_nr a page number
             */
            vfunc_is_selected(page_nr: number): boolean;
            vfunc_ready(context: PrintContext): void;
            /**
             * Renders a page to the preview.
             *
             * This is using the print context that was passed to the
             * [signal`Gtk`.PrintOperation::preview] handler together
             * with `preview`.
             *
             * A custom print preview should use this function to render
             * the currently selected page.
             *
             * Note that this function requires a suitable cairo context to
             * be associated with the print context.
             * @param page_nr the page to render
             */
            vfunc_render_page(page_nr: number): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace PrintSettings {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * A `GtkPrintSettings` object represents the settings of a print dialog in
         * a system-independent way.
         *
         * The main use for this object is that once you’ve printed you can get a
         * settings object that represents the settings the user chose, and the next
         * time you print you can pass that object in so that the user doesn’t have
         * to re-set all his settings.
         *
         * Its also possible to enumerate the settings so that you can easily save
         * the settings for the next time your app runs, or even store them in a
         * document. The predefined keys try to use shared values as much as possible
         * so that moving such a document between systems still works.
         */
        class PrintSettings extends GObject.Object {
            static $gtype: GObject.GType<PrintSettings>;

            // Constructors

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

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

            static ['new'](): PrintSettings;

            static new_from_file(file_name: string): PrintSettings;

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

            static new_from_key_file(key_file: GLib.KeyFile, group_name?: string | null): PrintSettings;

            // Methods

            /**
             * Copies a `GtkPrintSettings` object.
             * @returns a newly allocated copy of @other
             */
            copy(): PrintSettings;
            /**
             * Calls `func` for each key-value pair of `settings`.
             * @param func the function to call
             */
            foreach(func: PrintSettingsFunc): void;
            /**
             * Looks up the string value associated with `key`.
             * @param key a key
             * @returns the string value for @key
             */
            get(key: string): string | null;
            /**
             * Returns the boolean represented by the value
             * that is associated with `key`.
             *
             * The string “true” represents %TRUE, any other
             * string %FALSE.
             * @param key a key
             * @returns %TRUE, if @key maps to a true value.
             */
            get_bool(key: string): boolean;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_COLLATE.
             * @returns whether to collate the printed pages
             */
            get_collate(): boolean;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_DEFAULT_SOURCE.
             * @returns the default source
             */
            get_default_source(): string | null;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_DITHER.
             * @returns the dithering that is used
             */
            get_dither(): string | null;
            /**
             * Returns the double value associated with `key,` or 0.
             * @param key a key
             * @returns the double value of @key
             */
            get_double(key: string): number;
            /**
             * Returns the floating point number represented by
             * the value that is associated with `key,` or `default_val`
             * if the value does not represent a floating point number.
             *
             * Floating point numbers are parsed with g_ascii_strtod().
             * @param key a key
             * @param def the default value
             * @returns the floating point number associated with @key
             */
            get_double_with_default(key: string, def: number): number;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_DUPLEX.
             * @returns whether to print the output in duplex.
             */
            get_duplex(): PrintDuplex;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_FINISHINGS.
             * @returns the finishings
             */
            get_finishings(): string | null;
            /**
             * Returns the integer value of `key,` or 0.
             * @param key a key
             * @returns the integer value of @key
             */
            get_int(key: string): number;
            /**
             * Returns the value of `key,` interpreted as
             * an integer, or the default value.
             * @param key a key
             * @param def the default value
             * @returns the integer value of @key
             */
            get_int_with_default(key: string, def: number): number;
            /**
             * Returns the value associated with `key,` interpreted
             * as a length.
             *
             * The returned value is converted to `units`.
             * @param key a key
             * @param unit the unit of the return value
             * @returns the length value of @key, converted to @unit
             */
            get_length(key: string, unit: Unit | null): number;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_MEDIA_TYPE.
             *
             * The set of media types is defined in PWG 5101.1-2002 PWG.
             * @returns the media type
             */
            get_media_type(): string | null;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_N_COPIES.
             * @returns the number of copies to print
             */
            get_n_copies(): number;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_NUMBER_UP.
             * @returns the number of pages per sheet
             */
            get_number_up(): number;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT.
             * @returns layout of page in number-up mode
             */
            get_number_up_layout(): NumberUpLayout;
            /**
             * Get the value of %GTK_PRINT_SETTINGS_ORIENTATION,
             * converted to a `GtkPageOrientation`.
             * @returns the orientation
             */
            get_orientation(): PageOrientation;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_OUTPUT_BIN.
             * @returns the output bin
             */
            get_output_bin(): string | null;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_PAGE_RANGES.
             * @returns an array   of `GtkPageRange`s. Use g_free() to free the array when   it is no longer needed.
             */
            get_page_ranges(): PageRange[];
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_PAGE_SET.
             * @returns the set of pages to print
             */
            get_page_set(): PageSet;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_PAPER_HEIGHT,
             * converted to `unit`.
             * @param unit the unit for the return value
             * @returns the paper height, in units of @unit
             */
            get_paper_height(unit: Unit | null): number;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_PAPER_FORMAT,
             * converted to a `GtkPaperSize`.
             * @returns the paper size
             */
            get_paper_size(): PaperSize | null;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_PAPER_WIDTH,
             * converted to `unit`.
             * @param unit the unit for the return value
             * @returns the paper width, in units of @unit
             */
            get_paper_width(unit: Unit | null): number;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_PRINT_PAGES.
             * @returns which pages to print
             */
            get_print_pages(): PrintPages;
            /**
             * Convenience function to obtain the value of
             * %GTK_PRINT_SETTINGS_PRINTER.
             * @returns the printer name
             */
            get_printer(): string | null;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_PRINTER_LPI.
             * @returns the resolution in lpi (lines per inch)
             */
            get_printer_lpi(): number;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_QUALITY.
             * @returns the print quality
             */
            get_quality(): PrintQuality;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION.
             * @returns the resolution in dpi
             */
            get_resolution(): number;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION_X.
             * @returns the horizontal resolution in dpi
             */
            get_resolution_x(): number;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION_Y.
             * @returns the vertical resolution in dpi
             */
            get_resolution_y(): number;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_REVERSE.
             * @returns whether to reverse the order of the printed pages
             */
            get_reverse(): boolean;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_SCALE.
             * @returns the scale in percent
             */
            get_scale(): number;
            /**
             * Gets the value of %GTK_PRINT_SETTINGS_USE_COLOR.
             * @returns whether to use color
             */
            get_use_color(): boolean;
            /**
             * Returns %TRUE, if a value is associated with `key`.
             * @param key a key
             * @returns %TRUE, if @key has a value
             */
            has_key(key: string): boolean;
            /**
             * Reads the print settings from `file_name`.
             *
             * If the file could not be loaded then error is set to either
             * a `GFileError` or `GKeyFileError`.
             *
             * See [method`Gtk`.PrintSettings.to_file].
             * @param file_name the filename to read the settings from
             * @returns %TRUE on success
             */
            load_file(file_name: string): boolean;
            /**
             * Reads the print settings from the group `group_name` in `key_file`.
             *
             * If the file could not be loaded then error is set to either a
             * `GFileError` or `GKeyFileError`.
             * @param key_file the `GKeyFile` to retrieve the settings from
             * @param group_name the name of the group to use, or %NULL   to use the default “Print Settings”
             * @returns %TRUE on success
             */
            load_key_file(key_file: GLib.KeyFile, group_name?: string | null): boolean;
            /**
             * Associates `value` with `key`.
             * @param key a key
             * @param value a string value
             */
            set(key: string, value?: string | null): void;
            // Conflicted with GObject.Object.set
            set(...args: never[]): any;
            /**
             * Sets `key` to a boolean value.
             * @param key a key
             * @param value a boolean
             */
            set_bool(key: string, value: boolean): void;
            /**
             * Sets the value of %GTK_PRINT_SETTINGS_COLLATE.
             * @param collate whether to collate the output
             */
            set_collate(collate: boolean): void;
            /**
             * Sets the value of %GTK_PRINT_SETTINGS_DEFAULT_SOURCE.
             * @param default_source the default source
             */
            set_default_source(default_source: string): void;
            /**
             * Sets the value of %GTK_PRINT_SETTINGS_DITHER.
             * @param dither the dithering that is used
             */
            set_dither(dither: string): void;
            /**
             * Sets `key` to a double value.
             * @param key a key
             * @param value a double value
             */
            set_double(key: string, value: number): void;
            /**
             * Sets the value of %GTK_PRINT_SETTINGS_DUPLEX.
             * @param duplex a `GtkPrintDuplex` value
             */
            set_duplex(duplex: PrintDuplex | null): void;
            /**
             * Sets the value of %GTK_PRINT_SETTINGS_FINISHINGS.
             * @param finishings the finishings
             */
            set_finishings(finishings: string): void;
            /**
             * Sets `key` to an integer value.
             * @param key a key
             * @param value an integer
             */
            set_int(key: string, value: number): void;
            /**
             * Associates a length in units of `unit` with `key`.
             * @param key a key
             * @param value a length
             * @param unit the unit of @length
             */
            set_length(key: string, value: number, unit: Unit | null): void;
            /**
             * Sets the value of %GTK_PRINT_SETTINGS_MEDIA_TYPE.
             *
             * The set of media types is defined in PWG 5101.1-2002 PWG.
             * @param media_type the media type
             */
            set_media_type(media_type: string): void;
            /**
             * Sets the value of %GTK_PRINT_SETTINGS_N_COPIES.
             * @param num_copies the number of copies
             */
            set_n_copies(num_copies: number): void;
            /**
             * Sets the value of %GTK_PRINT_SETTINGS_NUMBER_UP.
             * @param number_up the number of pages per sheet
             */
            set_number_up(number_up: number): void;
            /**
             * Sets the value of %GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT.
             * @param number_up_layout a `GtkNumberUpLayout` value
             */
            set_number_up_layout(number_up_layout: NumberUpLayout | null): void;
            /**
             * Sets the value of %GTK_PRINT_SETTINGS_ORIENTATION.
             * @param orientation a page orientation
             */
            set_orientation(orientation: PageOrientation | null): void;
            /**
             * Sets the value of %GTK_PRINT_SETTINGS_OUTPUT_BIN.
             * @param output_bin the output bin
             */
            set_output_bin(output_bin: string): void;
            /**
             * Sets the value of %GTK_PRINT_SETTINGS_PAGE_RANGES.
             * @param page_ranges an array of `GtkPageRange`s
             */
            set_page_ranges(page_ranges: PageRange[]): void;
            /**
             * Sets the value of %GTK_PRINT_SETTINGS_PAGE_SET.
             * @param page_set a `GtkPageSet` value
             */
            set_page_set(page_set: PageSet | null): void;
            /**
             * Sets the value of %GTK_PRINT_SETTINGS_PAPER_HEIGHT.
             * @param height the paper height
             * @param unit the units of @height
             */
            set_paper_height(height: number, unit: Unit | null): void;
            /**
             * Sets the value of %GTK_PRINT_SETTINGS_PAPER_FORMAT,
             * %GTK_PRINT_SETTINGS_PAPER_WIDTH and
             * %GTK_PRINT_SETTINGS_PAPER_HEIGHT.
             * @param paper_size a paper size
             */
            set_paper_size(paper_size: PaperSize): void;
            /**
             * Sets the value of %GTK_PRINT_SETTINGS_PAPER_WIDTH.
             * @param width the paper width
             * @param unit the units of @width
             */
            set_paper_width(width: number, unit: Unit | null): void;
            /**
             * Sets the value of %GTK_PRINT_SETTINGS_PRINT_PAGES.
             * @param pages a `GtkPrintPages` value
             */
            set_print_pages(pages: PrintPages | null): void;
            /**
             * Convenience function to set %GTK_PRINT_SETTINGS_PRINTER
             * to `printer`.
             * @param printer the printer name
             */
            set_printer(printer: string): void;
            /**
             * Sets the value of %GTK_PRINT_SETTINGS_PRINTER_LPI.
             * @param lpi the resolution in lpi (lines per inch)
             */
            set_printer_lpi(lpi: number): void;
            /**
             * Sets the value of %GTK_PRINT_SETTINGS_QUALITY.
             * @param quality a `GtkPrintQuality` value
             */
            set_quality(quality: PrintQuality | null): void;
            /**
             * Sets the values of %GTK_PRINT_SETTINGS_RESOLUTION,
             * %GTK_PRINT_SETTINGS_RESOLUTION_X and
             * %GTK_PRINT_SETTINGS_RESOLUTION_Y.
             * @param resolution the resolution in dpi
             */
            set_resolution(resolution: number): void;
            /**
             * Sets the values of %GTK_PRINT_SETTINGS_RESOLUTION,
             * %GTK_PRINT_SETTINGS_RESOLUTION_X and
             * %GTK_PRINT_SETTINGS_RESOLUTION_Y.
             * @param resolution_x the horizontal resolution in dpi
             * @param resolution_y the vertical resolution in dpi
             */
            set_resolution_xy(resolution_x: number, resolution_y: number): void;
            /**
             * Sets the value of %GTK_PRINT_SETTINGS_REVERSE.
             * @param reverse whether to reverse the output
             */
            set_reverse(reverse: boolean): void;
            /**
             * Sets the value of %GTK_PRINT_SETTINGS_SCALE.
             * @param scale the scale in percent
             */
            set_scale(scale: number): void;
            /**
             * Sets the value of %GTK_PRINT_SETTINGS_USE_COLOR.
             * @param use_color whether to use color
             */
            set_use_color(use_color: boolean): void;
            /**
             * This function saves the print settings from `settings` to `file_name`.
             *
             * If the file could not be written then error is set to either a
             * `GFileError` or `GKeyFileError`.
             * @param file_name the file to save to
             * @returns %TRUE on success
             */
            to_file(file_name: string): boolean;
            /**
             * Serialize print settings to an a{sv} variant.
             * @returns a new, floating, `GVariant`
             */
            to_gvariant(): GLib.Variant;
            /**
             * This function adds the print settings from `settings` to `key_file`.
             * @param key_file the `GKeyFile` to save the print settings to
             * @param group_name the group to add the settings to in @key_file, or   %NULL to use the default “Print Settings”
             */
            to_key_file(key_file: GLib.KeyFile, group_name?: string | null): void;
            /**
             * Removes any value associated with `key`.
             *
             * This has the same effect as setting the value to %NULL.
             * @param key a key
             */
            unset(key: string): void;
        }

        namespace PrintUnixDialog {
            // Constructor properties interface

            interface ConstructorProps
                extends Dialog.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Native.ConstructorProps,
                    Root.ConstructorProps,
                    ShortcutManager.ConstructorProps {
                current_page: number;
                currentPage: number;
                embed_page_setup: boolean;
                embedPageSetup: boolean;
                has_selection: boolean;
                hasSelection: boolean;
                manual_capabilities: PrintCapabilities;
                manualCapabilities: PrintCapabilities;
                page_setup: PageSetup;
                pageSetup: PageSetup;
                print_settings: PrintSettings;
                printSettings: PrintSettings;
                selected_printer: Printer;
                selectedPrinter: Printer;
                support_selection: boolean;
                supportSelection: boolean;
            }
        }

        /**
         * `GtkPrintUnixDialog` implements a print dialog for platforms
         * which don’t provide a native print dialog, like Unix.
         *
         * ![An example GtkPrintUnixDialog](printdialog.png)
         *
         * It can be used very much like any other GTK dialog, at the cost of
         * the portability offered by the high-level printing API with
         * [class`Gtk`.PrintOperation].
         *
         * In order to print something with `GtkPrintUnixDialog`, you need to
         * use [method`Gtk`.PrintUnixDialog.get_selected_printer] to obtain a
         * [class`Gtk`.Printer] object and use it to construct a [class`Gtk`.PrintJob]
         * using [ctor`Gtk`.PrintJob.new].
         *
         * `GtkPrintUnixDialog` uses the following response values:
         *
         * - %GTK_RESPONSE_OK: for the “Print” button
         * - %GTK_RESPONSE_APPLY: for the “Preview” button
         * - %GTK_RESPONSE_CANCEL: for the “Cancel” button
         *
         * # GtkPrintUnixDialog as GtkBuildable
         *
         * The `GtkPrintUnixDialog` implementation of the `GtkBuildable` interface
         * exposes its `notebook` internal children with the name “notebook”.
         *
         * An example of a `GtkPrintUnixDialog` UI definition fragment:
         *
         * ```xml
         * <object class="GtkPrintUnixDialog" id="dialog1">
         *   <child internal-child="notebook">
         *     <object class="GtkNotebook" id="notebook">
         *       <child>
         *         <object type="GtkNotebookPage">
         *           <property name="tab_expand">False</property>
         *           <property name="tab_fill">False</property>
         *           <property name="tab">
         *             <object class="GtkLabel" id="tablabel">
         *               <property name="label">Tab label</property>
         *             </object>
         *           </property>
         *           <property name="child">
         *             <object class="GtkLabel" id="tabcontent">
         *               <property name="label">Content on notebook tab</property>
         *             </object>
         *           </property>
         *         </object>
         *       </child>
         *     </object>
         *   </child>
         * </object>
         * ```
         *
         * # CSS nodes
         *
         * `GtkPrintUnixDialog` has a single CSS node with name window. The style classes
         * dialog and print are added.
         */
        class PrintUnixDialog
            extends Dialog
            implements Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager
        {
            static $gtype: GObject.GType<PrintUnixDialog>;

            // Properties

            /**
             * The current page in the document.
             */
            get current_page(): number;
            set current_page(val: number);
            /**
             * The current page in the document.
             */
            get currentPage(): number;
            set currentPage(val: number);
            /**
             * %TRUE if the page setup controls are embedded.
             */
            get embed_page_setup(): boolean;
            set embed_page_setup(val: boolean);
            /**
             * %TRUE if the page setup controls are embedded.
             */
            get embedPageSetup(): boolean;
            set embedPageSetup(val: boolean);
            /**
             * Whether the application has a selection.
             */
            get has_selection(): boolean;
            set has_selection(val: boolean);
            /**
             * Whether the application has a selection.
             */
            get hasSelection(): boolean;
            set hasSelection(val: boolean);
            /**
             * Capabilities the application can handle.
             */
            get manual_capabilities(): PrintCapabilities;
            set manual_capabilities(val: PrintCapabilities);
            /**
             * Capabilities the application can handle.
             */
            get manualCapabilities(): PrintCapabilities;
            set manualCapabilities(val: PrintCapabilities);
            /**
             * The `GtkPageSetup` object to use.
             */
            get page_setup(): PageSetup;
            set page_setup(val: PageSetup);
            /**
             * The `GtkPageSetup` object to use.
             */
            get pageSetup(): PageSetup;
            set pageSetup(val: PageSetup);
            /**
             * The `GtkPrintSettings` object used for this dialog.
             */
            get print_settings(): PrintSettings;
            set print_settings(val: PrintSettings);
            /**
             * The `GtkPrintSettings` object used for this dialog.
             */
            get printSettings(): PrintSettings;
            set printSettings(val: PrintSettings);
            /**
             * The `GtkPrinter` which is selected.
             */
            get selected_printer(): Printer;
            /**
             * The `GtkPrinter` which is selected.
             */
            get selectedPrinter(): Printer;
            /**
             * Whether the dialog supports selection.
             */
            get support_selection(): boolean;
            set support_selection(val: boolean);
            /**
             * Whether the dialog supports selection.
             */
            get supportSelection(): boolean;
            set supportSelection(val: boolean);

            // Constructors

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

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

            static ['new'](title?: string | null, parent?: Window | null): PrintUnixDialog;
            // Conflicted with Gtk.Dialog.new

            static ['new'](...args: never[]): any;

            // Methods

            /**
             * Adds a custom tab to the print dialog.
             * @param child the widget to put in the custom tab
             * @param tab_label the widget to use as tab label
             */
            add_custom_tab(child: Widget, tab_label: Widget): void;
            /**
             * Gets the current page of the `GtkPrintUnixDialog`.
             * @returns the current page of @dialog
             */
            get_current_page(): number;
            /**
             * Gets whether to embed the page setup.
             * @returns whether to embed the page setup
             */
            get_embed_page_setup(): boolean;
            /**
             * Gets whether there is a selection.
             * @returns whether there is a selection
             */
            get_has_selection(): boolean;
            /**
             * Gets the capabilities that have been set on this `GtkPrintUnixDialog`.
             * @returns the printing capabilities
             */
            get_manual_capabilities(): PrintCapabilities;
            /**
             * Gets the page setup that is used by the `GtkPrintUnixDialog`.
             * @returns the page setup of @dialog.
             */
            get_page_setup(): PageSetup;
            /**
             * Gets whether a page setup was set by the user.
             * @returns whether a page setup was set by user.
             */
            get_page_setup_set(): boolean;
            /**
             * Gets the currently selected printer.
             * @returns the currently selected printer
             */
            get_selected_printer(): Printer | null;
            /**
             * Gets a new `GtkPrintSettings` object that represents the
             * current values in the print dialog.
             *
             * Note that this creates a new object, and you need to unref
             * it if don’t want to keep it.
             * @returns a new `GtkPrintSettings` object with the values from @dialog
             */
            get_settings(): PrintSettings;
            // Conflicted with Gtk.Widget.get_settings
            get_settings(...args: never[]): any;
            /**
             * Gets whether the print dialog allows user to print a selection.
             * @returns whether the application supports print of selection
             */
            get_support_selection(): boolean;
            /**
             * Sets the current page number.
             *
             * If `current_page` is not -1, this enables the current page choice
             * for the range of pages to print.
             * @param current_page the current page number.
             */
            set_current_page(current_page: number): void;
            /**
             * Embed page size combo box and orientation combo box into page setup page.
             * @param embed embed page setup selection
             */
            set_embed_page_setup(embed: boolean): void;
            /**
             * Sets whether a selection exists.
             * @param has_selection %TRUE indicates that a selection exists
             */
            set_has_selection(has_selection: boolean): void;
            /**
             * This lets you specify the printing capabilities your application
             * supports.
             *
             * For instance, if you can handle scaling the output then you pass
             * %GTK_PRINT_CAPABILITY_SCALE. If you don’t pass that, then the dialog
             * will only let you select the scale if the printing system automatically
             * handles scaling.
             * @param capabilities the printing capabilities of your application
             */
            set_manual_capabilities(capabilities: PrintCapabilities | null): void;
            /**
             * Sets the page setup of the `GtkPrintUnixDialog`.
             * @param page_setup a `GtkPageSetup`
             */
            set_page_setup(page_setup: PageSetup): void;
            /**
             * Sets the `GtkPrintSettings` for the `GtkPrintUnixDialog`.
             *
             * Typically, this is used to restore saved print settings
             * from a previous print operation before the print dialog
             * is shown.
             * @param settings a `GtkPrintSettings`
             */
            set_settings(settings?: PrintSettings | null): void;
            /**
             * Sets whether the print dialog allows user to print a selection.
             * @param support_selection %TRUE to allow print selection
             */
            set_support_selection(support_selection: boolean): void;

            // Inherited properties
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace Printer {
            // Signal callback interfaces

            interface DetailsAcquired {
                (success: boolean): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                accepting_jobs: boolean;
                acceptingJobs: boolean;
                accepts_pdf: boolean;
                acceptsPdf: boolean;
                accepts_ps: boolean;
                acceptsPs: boolean;
                icon_name: string;
                iconName: string;
                is_virtual: boolean;
                isVirtual: boolean;
                job_count: number;
                jobCount: number;
                location: string;
                name: string;
                paused: boolean;
                state_message: string;
                stateMessage: string;
            }
        }

        /**
         * A `GtkPrinter` object represents a printer.
         *
         * You only need to deal directly with printers if you use the
         * non-portable [class`Gtk`.PrintUnixDialog] API.
         *
         * A `GtkPrinter` allows to get status information about the printer,
         * such as its description, its location, the number of queued jobs,
         * etc. Most importantly, a `GtkPrinter` object can be used to create
         * a [class`Gtk`.PrintJob] object, which lets you print to the printer.
         */
        class Printer extends GObject.Object {
            static $gtype: GObject.GType<Printer>;

            // Properties

            /**
             * %TRUE if the printer is accepting jobs.
             */
            get accepting_jobs(): boolean;
            /**
             * %TRUE if the printer is accepting jobs.
             */
            get acceptingJobs(): boolean;
            /**
             * %TRUE if this printer can accept PDF.
             */
            get accepts_pdf(): boolean;
            /**
             * %TRUE if this printer can accept PDF.
             */
            get acceptsPdf(): boolean;
            /**
             * %TRUE if this printer can accept PostScript.
             */
            get accepts_ps(): boolean;
            /**
             * %TRUE if this printer can accept PostScript.
             */
            get acceptsPs(): boolean;
            /**
             * Icon name to use for the printer.
             */
            get icon_name(): string;
            /**
             * Icon name to use for the printer.
             */
            get iconName(): string;
            /**
             * %FALSE if this represents a real hardware device.
             */
            get is_virtual(): boolean;
            /**
             * %FALSE if this represents a real hardware device.
             */
            get isVirtual(): boolean;
            /**
             * Number of jobs queued in the printer.
             */
            get job_count(): number;
            /**
             * Number of jobs queued in the printer.
             */
            get jobCount(): number;
            /**
             * Information about the location of the printer.
             */
            get location(): string;
            /**
             * The name of the printer.
             */
            get name(): string;
            /**
             * %TRUE if this printer is paused.
             *
             * A paused printer still accepts jobs, but it does
             * not print them.
             */
            get paused(): boolean;
            /**
             * String giving the current status of the printer.
             */
            get state_message(): string;
            /**
             * String giving the current status of the printer.
             */
            get stateMessage(): string;

            // Constructors

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

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

            static ['new'](name: string, backend: PrintBackend, virtual_: boolean): Printer;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'details-acquired', callback: (_source: this, success: boolean) => void): number;
            connect_after(signal: 'details-acquired', callback: (_source: this, success: boolean) => void): number;
            emit(signal: 'details-acquired', success: boolean): void;

            // Methods

            /**
             * Compares two printers.
             * @param b another `GtkPrinter`
             * @returns 0 if the printer match, a negative value if @a < @b,   or a positive value if @a > @b
             */
            compare(b: Printer): number;
            /**
             * Returns the backend of the printer.
             * @returns the backend of @printer
             */
            get_backend(): PrintBackend;
            /**
             * Returns the printer’s capabilities.
             *
             * This is useful when you’re using `GtkPrintUnixDialog`’s
             * manual-capabilities setting and need to know which settings
             * the printer can handle and which you must handle yourself.
             *
             * This will return 0 unless the printer’s details are
             * available, see [method`Gtk`.Printer.has_details] and
             * [method`Gtk`.Printer.request_details].
             * @returns the printer’s capabilities
             */
            get_capabilities(): PrintCapabilities;
            /**
             * Returns default page size of `printer`.
             * @returns a newly allocated `GtkPageSetup` with default page size   of the printer.
             */
            get_default_page_size(): PageSetup;
            /**
             * Gets the description of the printer.
             * @returns the description of @printer
             */
            get_description(): string;
            /**
             * Retrieve the hard margins of `printer`.
             *
             * These are the margins that define the area at the borders
             * of the paper that the printer cannot print to.
             *
             * Note: This will not succeed unless the printer’s details are
             * available, see [method`Gtk`.Printer.has_details] and
             * [method`Gtk`.Printer.request_details].
             * @returns %TRUE iff the hard margins were retrieved
             */
            get_hard_margins(): [boolean, number, number, number, number];
            /**
             * Retrieve the hard margins of `printer` for `paper_size`.
             *
             * These are the margins that define the area at the borders
             * of the paper that the printer cannot print to.
             *
             * Note: This will not succeed unless the printer’s details are
             * available, see [method`Gtk`.Printer.has_details] and
             * [method`Gtk`.Printer.request_details].
             * @param paper_size a `GtkPaperSize`
             * @returns %TRUE iff the hard margins were retrieved
             */
            get_hard_margins_for_paper_size(paper_size: PaperSize): [boolean, number, number, number, number];
            /**
             * Gets the name of the icon to use for the printer.
             * @returns the icon name for @printer
             */
            get_icon_name(): string;
            /**
             * Gets the number of jobs currently queued on the printer.
             * @returns the number of jobs on @printer
             */
            get_job_count(): number;
            /**
             * Returns a description of the location of the printer.
             * @returns the location of @printer
             */
            get_location(): string;
            /**
             * Returns the name of the printer.
             * @returns the name of @printer
             */
            get_name(): string;
            /**
             * Returns the state message describing the current state
             * of the printer.
             * @returns the state message of @printer
             */
            get_state_message(): string;
            /**
             * Returns whether the printer details are available.
             * @returns %TRUE if @printer details are available
             */
            has_details(): boolean;
            /**
             * Returns whether the printer is accepting jobs
             * @returns %TRUE if @printer is accepting jobs
             */
            is_accepting_jobs(): boolean;
            /**
             * Returns whether the printer is currently active (i.e.
             * accepts new jobs).
             * @returns %TRUE if @printer is active
             */
            is_active(): boolean;
            /**
             * Returns whether the printer is the default printer.
             * @returns %TRUE if @printer is the default
             */
            is_default(): boolean;
            /**
             * Returns whether the printer is currently paused.
             *
             * A paused printer still accepts jobs, but it is not
             * printing them.
             * @returns %TRUE if @printer is paused
             */
            is_paused(): boolean;
            /**
             * Lists all the paper sizes `printer` supports.
             *
             * This will return and empty list unless the printer’s details
             * are available, see [method`Gtk`.Printer.has_details] and
             * [method`Gtk`.Printer.request_details].
             * @returns a newly   allocated list of newly allocated `GtkPageSetup`s.
             */
            list_papers(): PageSetup[];
            /**
             * Requests the printer details.
             *
             * When the details are available, the
             * [signal`Gtk`.Printer::details-acquired] signal
             * will be emitted on `printer`.
             */
            request_details(): void;
        }

        namespace ProgressBar {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    AccessibleRange.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Orientable.ConstructorProps {
                ellipsize: Pango.EllipsizeMode;
                fraction: number;
                inverted: boolean;
                pulse_step: number;
                pulseStep: number;
                show_text: boolean;
                showText: boolean;
                text: string;
            }
        }

        /**
         * `GtkProgressBar` is typically used to display the progress of a long
         * running operation.
         *
         * It provides a visual clue that processing is underway. `GtkProgressBar`
         * can be used in two different modes: percentage mode and activity mode.
         *
         * ![An example GtkProgressBar](progressbar.png)
         *
         * When an application can determine how much work needs to take place
         * (e.g. read a fixed number of bytes from a file) and can monitor its
         * progress, it can use the `GtkProgressBar` in percentage mode and the
         * user sees a growing bar indicating the percentage of the work that
         * has been completed. In this mode, the application is required to call
         * [method`Gtk`.ProgressBar.set_fraction] periodically to update the progress bar.
         *
         * When an application has no accurate way of knowing the amount of work
         * to do, it can use the `GtkProgressBar` in activity mode, which shows
         * activity by a block moving back and forth within the progress area. In
         * this mode, the application is required to call [method`Gtk`.ProgressBar.pulse]
         * periodically to update the progress bar.
         *
         * There is quite a bit of flexibility provided to control the appearance
         * of the `GtkProgressBar`. Functions are provided to control the orientation
         * of the bar, optional text can be displayed along with the bar, and the
         * step size used in activity mode can be set.
         *
         * # CSS nodes
         *
         * ```
         * progressbar[.osd]
         * ├── [text]
         * ╰── trough[.empty][.full]
         *     ╰── progress[.pulse]
         * ```
         *
         * `GtkProgressBar` has a main CSS node with name progressbar and subnodes with
         * names text and trough, of which the latter has a subnode named progress. The
         * text subnode is only present if text is shown. The progress subnode has the
         * style class .pulse when in activity mode. It gets the style classes .left,
         * .right, .top or .bottom added when the progress 'touches' the corresponding
         * end of the GtkProgressBar. The .osd class on the progressbar node is for use
         * in overlays like the one Epiphany has for page loading progress.
         *
         * # Accessibility
         *
         * `GtkProgressBar` uses the %GTK_ACCESSIBLE_ROLE_PROGRESS_BAR role.
         */
        class ProgressBar
            extends Widget
            implements Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable
        {
            static $gtype: GObject.GType<ProgressBar>;

            // Properties

            /**
             * The preferred place to ellipsize the string.
             *
             * The text will be ellipsized if the progress bar does not have enough room
             * to display the entire string, specified as a `PangoEllipsizeMode`.
             *
             * Note that setting this property to a value other than
             * %PANGO_ELLIPSIZE_NONE has the side-effect that the progress bar requests
             * only enough space to display the ellipsis ("..."). Another means to set a
             * progress bar's width is [method`Gtk`.Widget.set_size_request].
             */
            get ellipsize(): Pango.EllipsizeMode;
            set ellipsize(val: Pango.EllipsizeMode);
            /**
             * The fraction of total work that has been completed.
             */
            get fraction(): number;
            set fraction(val: number);
            /**
             * Invert the direction in which the progress bar grows.
             */
            get inverted(): boolean;
            set inverted(val: boolean);
            /**
             * The fraction of total progress to move the bounding block when pulsed.
             */
            get pulse_step(): number;
            set pulse_step(val: number);
            /**
             * The fraction of total progress to move the bounding block when pulsed.
             */
            get pulseStep(): number;
            set pulseStep(val: number);
            /**
             * Sets whether the progress bar will show a text in addition
             * to the bar itself.
             *
             * The shown text is either the value of the [property`Gtk`.ProgressBar:text]
             * property or, if that is %NULL, the [property`Gtk`.ProgressBar:fraction]
             * value, as a percentage.
             *
             * To make a progress bar that is styled and sized suitably for showing text
             * (even if the actual text is blank), set [property`Gtk`.ProgressBar:show-text]
             * to %TRUE and [property`Gtk`.ProgressBar:text] to the empty string (not %NULL).
             */
            get show_text(): boolean;
            set show_text(val: boolean);
            /**
             * Sets whether the progress bar will show a text in addition
             * to the bar itself.
             *
             * The shown text is either the value of the [property`Gtk`.ProgressBar:text]
             * property or, if that is %NULL, the [property`Gtk`.ProgressBar:fraction]
             * value, as a percentage.
             *
             * To make a progress bar that is styled and sized suitably for showing text
             * (even if the actual text is blank), set [property`Gtk`.ProgressBar:show-text]
             * to %TRUE and [property`Gtk`.ProgressBar:text] to the empty string (not %NULL).
             */
            get showText(): boolean;
            set showText(val: boolean);
            /**
             * Text to be displayed in the progress bar.
             */
            get text(): string;
            set text(val: string);

            // Constructors

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

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

            static ['new'](): ProgressBar;

            // Methods

            /**
             * Returns the ellipsizing position of the progress bar.
             *
             * See [method`Gtk`.ProgressBar.set_ellipsize].
             * @returns `PangoEllipsizeMode`
             */
            get_ellipsize(): Pango.EllipsizeMode;
            /**
             * Returns the current fraction of the task that’s been completed.
             * @returns a fraction from 0.0 to 1.0
             */
            get_fraction(): number;
            /**
             * Returns whether the progress bar is inverted.
             * @returns %TRUE if the progress bar is inverted
             */
            get_inverted(): boolean;
            /**
             * Retrieves the pulse step.
             *
             * See [method`Gtk`.ProgressBar.set_pulse_step].
             * @returns a fraction from 0.0 to 1.0
             */
            get_pulse_step(): number;
            /**
             * Returns whether the `GtkProgressBar` shows text.
             *
             * See [method`Gtk`.ProgressBar.set_show_text].
             * @returns %TRUE if text is shown in the progress bar
             */
            get_show_text(): boolean;
            /**
             * Retrieves the text that is displayed with the progress bar.
             *
             * The return value is a reference to the text, not a copy of it,
             * so will become invalid if you change the text in the progress bar.
             * @returns the text
             */
            get_text(): string | null;
            /**
             * Indicates that some progress has been made, but you don’t know how much.
             *
             * Causes the progress bar to enter “activity mode,” where a block
             * bounces back and forth. Each call to [method`Gtk`.ProgressBar.pulse]
             * causes the block to move by a little bit (the amount of movement
             * per pulse is determined by [method`Gtk`.ProgressBar.set_pulse_step]).
             */
            pulse(): void;
            /**
             * Sets the mode used to ellipsize the text.
             *
             * The text is ellipsized if there is not enough space
             * to render the entire string.
             * @param mode a `PangoEllipsizeMode`
             */
            set_ellipsize(mode: Pango.EllipsizeMode | null): void;
            /**
             * Causes the progress bar to “fill in” the given fraction
             * of the bar.
             *
             * The fraction should be between 0.0 and 1.0, inclusive.
             * @param fraction fraction of the task that’s been completed
             */
            set_fraction(fraction: number): void;
            /**
             * Sets whether the progress bar is inverted.
             *
             * Progress bars normally grow from top to bottom or left to right.
             * Inverted progress bars grow in the opposite direction.
             * @param inverted %TRUE to invert the progress bar
             */
            set_inverted(inverted: boolean): void;
            /**
             * Sets the fraction of total progress bar length to move the
             * bouncing block.
             *
             * The bouncing block is moved when [method`Gtk`.ProgressBar.pulse]
             * is called.
             * @param fraction fraction between 0.0 and 1.0
             */
            set_pulse_step(fraction: number): void;
            /**
             * Sets whether the progress bar will show text next to the bar.
             *
             * The shown text is either the value of the [property`Gtk`.ProgressBar:text]
             * property or, if that is %NULL, the [property`Gtk`.ProgressBar:fraction] value,
             * as a percentage.
             *
             * To make a progress bar that is styled and sized suitably for containing
             * text (even if the actual text is blank), set [property`Gtk`.ProgressBar:show-text]
             * to %TRUE and [property`Gtk`.ProgressBar:text] to the empty string (not %NULL).
             * @param show_text whether to show text
             */
            set_show_text(show_text: boolean): void;
            /**
             * Causes the given `text` to appear next to the progress bar.
             *
             * If `text` is %NULL and [property`Gtk`.ProgressBar:show-text] is %TRUE,
             * the current value of [property`Gtk`.ProgressBar:fraction] will be displayed
             * as a percentage.
             *
             * If `text` is non-%NULL and [property`Gtk`.ProgressBar:show-text] is %TRUE,
             * the text will be displayed. In this case, it will not display the progress
             * percentage. If `text` is the empty string, the progress bar will still
             * be styled and sized suitably for containing text, as long as
             * [property`Gtk`.ProgressBar:show-text] is %TRUE.
             * @param text a UTF-8 string
             */
            set_text(text?: string | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Sets the current value of the accessible range.
             *
             * This operation should behave similarly as if the user performed the
             * action.
             * @param value the value to set
             */
            vfunc_set_current_value(value: number): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        /**
         * A `GObject` property value in a `GtkExpression`.
         */
        class PropertyExpression extends Expression {
            static $gtype: GObject.GType<PropertyExpression>;

            // Constructors

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

            static ['new'](
                this_type: GObject.GType,
                expression: Expression | null,
                property_name: string,
            ): PropertyExpression;

            static new_for_pspec(expression: Expression | null, pspec: GObject.ParamSpec): PropertyExpression;

            // Methods

            /**
             * Gets the expression specifying the object of
             * a property expression.
             * @returns the object expression
             */
            get_expression(): Expression | null;
            /**
             * Gets the `GParamSpec` specifying the property of
             * a property expression.
             * @returns the `GParamSpec` for the property
             */
            get_pspec(): GObject.ParamSpec;
        }

        namespace Range {
            // Signal callback interfaces

            interface AdjustBounds {
                (value: number): void;
            }

            interface ChangeValue {
                (scroll: ScrollType, value: number): boolean;
            }

            interface MoveSlider {
                (step: ScrollType): void;
            }

            interface ValueChanged {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    AccessibleRange.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Orientable.ConstructorProps {
                adjustment: Adjustment;
                fill_level: number;
                fillLevel: number;
                inverted: boolean;
                restrict_to_fill_level: boolean;
                restrictToFillLevel: boolean;
                round_digits: number;
                roundDigits: number;
                show_fill_level: boolean;
                showFillLevel: boolean;
            }
        }

        /**
         * `GtkRange` is the common base class for widgets which visualize an
         * adjustment.
         *
         * Widgets that are derived from `GtkRange` include
         * [class`Gtk`.Scale] and [class`Gtk`.Scrollbar].
         *
         * Apart from signals for monitoring the parameters of the adjustment,
         * `GtkRange` provides properties and methods for setting a
         * “fill level” on range widgets. See [method`Gtk`.Range.set_fill_level].
         *
         * # Shortcuts and Gestures
         *
         * The `GtkRange` slider is draggable. Holding the <kbd>Shift</kbd> key while
         * dragging, or initiating the drag with a long-press will enable the
         * fine-tuning mode.
         */
        class Range extends Widget implements Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable {
            static $gtype: GObject.GType<Range>;

            // Properties

            /**
             * The adjustment that is controlled by the range.
             */
            get adjustment(): Adjustment;
            set adjustment(val: Adjustment);
            /**
             * The fill level (e.g. prebuffering of a network stream).
             */
            get fill_level(): number;
            set fill_level(val: number);
            /**
             * The fill level (e.g. prebuffering of a network stream).
             */
            get fillLevel(): number;
            set fillLevel(val: number);
            /**
             * If %TRUE, the direction in which the slider moves is inverted.
             */
            get inverted(): boolean;
            set inverted(val: boolean);
            /**
             * Controls whether slider movement is restricted to an
             * upper boundary set by the fill level.
             */
            get restrict_to_fill_level(): boolean;
            set restrict_to_fill_level(val: boolean);
            /**
             * Controls whether slider movement is restricted to an
             * upper boundary set by the fill level.
             */
            get restrictToFillLevel(): boolean;
            set restrictToFillLevel(val: boolean);
            /**
             * The number of digits to round the value to when
             * it changes.
             *
             * See [signal`Gtk`.Range::change-value].
             */
            get round_digits(): number;
            set round_digits(val: number);
            /**
             * The number of digits to round the value to when
             * it changes.
             *
             * See [signal`Gtk`.Range::change-value].
             */
            get roundDigits(): number;
            set roundDigits(val: number);
            /**
             * Controls whether fill level indicator graphics are displayed
             * on the trough.
             */
            get show_fill_level(): boolean;
            set show_fill_level(val: boolean);
            /**
             * Controls whether fill level indicator graphics are displayed
             * on the trough.
             */
            get showFillLevel(): boolean;
            set showFillLevel(val: boolean);

            // Constructors

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

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

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'adjust-bounds', callback: (_source: this, value: number) => void): number;
            connect_after(signal: 'adjust-bounds', callback: (_source: this, value: number) => void): number;
            emit(signal: 'adjust-bounds', value: number): void;
            connect(
                signal: 'change-value',
                callback: (_source: this, scroll: ScrollType, value: number) => boolean,
            ): number;
            connect_after(
                signal: 'change-value',
                callback: (_source: this, scroll: ScrollType, value: number) => boolean,
            ): number;
            emit(signal: 'change-value', scroll: ScrollType, value: number): void;
            connect(signal: 'move-slider', callback: (_source: this, step: ScrollType) => void): number;
            connect_after(signal: 'move-slider', callback: (_source: this, step: ScrollType) => void): number;
            emit(signal: 'move-slider', step: ScrollType): void;
            connect(signal: 'value-changed', callback: (_source: this) => void): number;
            connect_after(signal: 'value-changed', callback: (_source: this) => void): number;
            emit(signal: 'value-changed'): void;

            // Virtual methods

            vfunc_adjust_bounds(new_value: number): void;
            vfunc_change_value(scroll: ScrollType, new_value: number): boolean;
            vfunc_get_range_border(border_: Border): void;
            vfunc_move_slider(scroll: ScrollType): void;
            vfunc_value_changed(): void;

            // Methods

            /**
             * Get the adjustment which is the “model” object for `GtkRange`.
             * @returns a `GtkAdjustment`
             */
            get_adjustment(): Adjustment;
            /**
             * Gets the current position of the fill level indicator.
             * @returns The current fill level
             */
            get_fill_level(): number;
            /**
             * Gets whether the `GtkRange` respects text direction.
             *
             * See [method`Gtk`.Range.set_flippable].
             * @returns %TRUE if the range is flippable
             */
            get_flippable(): boolean;
            /**
             * Gets whether the range is inverted.
             *
             * See [method`Gtk`.Range.set_inverted].
             * @returns %TRUE if the range is inverted
             */
            get_inverted(): boolean;
            /**
             * This function returns the area that contains the range’s trough,
             * in coordinates relative to `range'`s origin.
             *
             * This function is useful mainly for `GtkRange` subclasses.
             */
            get_range_rect(): Gdk.Rectangle;
            /**
             * Gets whether the range is restricted to the fill level.
             * @returns %TRUE if @range is restricted to the fill level.
             */
            get_restrict_to_fill_level(): boolean;
            /**
             * Gets the number of digits to round the value to when
             * it changes.
             *
             * See [signal`Gtk`.Range::change-value].
             * @returns the number of digits to round to
             */
            get_round_digits(): number;
            /**
             * Gets whether the range displays the fill level graphically.
             * @returns %TRUE if @range shows the fill level.
             */
            get_show_fill_level(): boolean;
            /**
             * This function returns sliders range along the long dimension,
             * in widget->window coordinates.
             *
             * This function is useful mainly for `GtkRange` subclasses.
             */
            get_slider_range(): [number, number];
            /**
             * This function is useful mainly for `GtkRange` subclasses.
             *
             * See [method`Gtk`.Range.set_slider_size_fixed].
             * @returns whether the range’s slider has a fixed size.
             */
            get_slider_size_fixed(): boolean;
            /**
             * Gets the current value of the range.
             * @returns current value of the range.
             */
            get_value(): number;
            /**
             * Sets the adjustment to be used as the “model” object for the `GtkRange`
             *
             * The adjustment indicates the current range value, the minimum and
             * maximum range values, the step/page increments used for keybindings
             * and scrolling, and the page size.
             *
             * The page size is normally 0 for `GtkScale` and nonzero for `GtkScrollbar`,
             * and indicates the size of the visible area of the widget being scrolled.
             * The page size affects the size of the scrollbar slider.
             * @param adjustment a `GtkAdjustment`
             */
            set_adjustment(adjustment: Adjustment): void;
            /**
             * Set the new position of the fill level indicator.
             *
             * The “fill level” is probably best described by its most prominent
             * use case, which is an indicator for the amount of pre-buffering in
             * a streaming media player. In that use case, the value of the range
             * would indicate the current play position, and the fill level would
             * be the position up to which the file/stream has been downloaded.
             *
             * This amount of prebuffering can be displayed on the range’s trough
             * and is themeable separately from the trough. To enable fill level
             * display, use [method`Gtk`.Range.set_show_fill_level]. The range defaults
             * to not showing the fill level.
             *
             * Additionally, it’s possible to restrict the range’s slider position
             * to values which are smaller than the fill level. This is controlled
             * by [method`Gtk`.Range.set_restrict_to_fill_level] and is by default
             * enabled.
             * @param fill_level the new position of the fill level indicator
             */
            set_fill_level(fill_level: number): void;
            /**
             * Sets whether the `GtkRange` respects text direction.
             *
             * If a range is flippable, it will switch its direction
             * if it is horizontal and its direction is %GTK_TEXT_DIR_RTL.
             *
             * See [method`Gtk`.Widget.get_direction].
             * @param flippable %TRUE to make the range flippable
             */
            set_flippable(flippable: boolean): void;
            /**
             * Sets the step and page sizes for the range.
             *
             * The step size is used when the user clicks the `GtkScrollbar`
             * arrows or moves a `GtkScale` via arrow keys. The page size
             * is used for example when moving via Page Up or Page Down keys.
             * @param step step size
             * @param page page size
             */
            set_increments(step: number, page: number): void;
            /**
             * Sets whether to invert the range.
             *
             * Ranges normally move from lower to higher values as the
             * slider moves from top to bottom or left to right. Inverted
             * ranges have higher values at the top or on the right rather
             * than on the bottom or left.
             * @param setting %TRUE to invert the range
             */
            set_inverted(setting: boolean): void;
            /**
             * Sets the allowable values in the `GtkRange`.
             *
             * The range value is clamped to be between `min` and `max`.
             * (If the range has a non-zero page size, it is clamped
             * between `min` and `max` - page-size.)
             * @param min minimum range value
             * @param max maximum range value
             */
            set_range(min: number, max: number): void;
            /**
             * Sets whether the slider is restricted to the fill level.
             *
             * See [method`Gtk`.Range.set_fill_level] for a general description
             * of the fill level concept.
             * @param restrict_to_fill_level Whether the fill level restricts slider movement.
             */
            set_restrict_to_fill_level(restrict_to_fill_level: boolean): void;
            /**
             * Sets the number of digits to round the value to when
             * it changes.
             *
             * See [signal`Gtk`.Range::change-value].
             * @param round_digits the precision in digits, or -1
             */
            set_round_digits(round_digits: number): void;
            /**
             * Sets whether a graphical fill level is show on the trough.
             *
             * See [method`Gtk`.Range.set_fill_level] for a general description
             * of the fill level concept.
             * @param show_fill_level Whether a fill level indicator graphics is shown.
             */
            set_show_fill_level(show_fill_level: boolean): void;
            /**
             * Sets whether the range’s slider has a fixed size, or a size that
             * depends on its adjustment’s page size.
             *
             * This function is useful mainly for `GtkRange` subclasses.
             * @param size_fixed %TRUE to make the slider size constant
             */
            set_slider_size_fixed(size_fixed: boolean): void;
            /**
             * Sets the current value of the range.
             *
             * If the value is outside the minimum or maximum range values,
             * it will be clamped to fit inside them. The range emits the
             * [signal`Gtk`.Range::value-changed] signal if the value changes.
             * @param value new value of the range
             */
            set_value(value: number): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Sets the current value of the accessible range.
             *
             * This operation should behave similarly as if the user performed the
             * action.
             * @param value the value to set
             */
            vfunc_set_current_value(value: number): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace RecentManager {
            // Signal callback interfaces

            interface Changed {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                filename: string;
                size: number;
            }
        }

        /**
         * `GtkRecentManager` manages and looks up recently used files.
         *
         * Each recently used file is identified by its URI, and has meta-data
         * associated to it, like the names and command lines of the applications
         * that have registered it, the number of time each application has
         * registered the same file, the mime type of the file and whether
         * the file should be displayed only by the applications that have
         * registered it.
         *
         * The recently used files list is per user.
         *
         * `GtkRecentManager` acts like a database of all the recently
         * used files. You can create new `GtkRecentManager` objects, but
         * it is more efficient to use the default manager created by GTK.
         *
         * Adding a new recently used file is as simple as:
         *
         * ```c
         * GtkRecentManager *manager;
         *
         * manager = gtk_recent_manager_get_default ();
         * gtk_recent_manager_add_item (manager, file_uri);
         * ```
         *
         * The `GtkRecentManager` will try to gather all the needed information
         * from the file itself through GIO.
         *
         * Looking up the meta-data associated with a recently used file
         * given its URI requires calling [method`Gtk`.RecentManager.lookup_item]:
         *
         * ```c
         * GtkRecentManager *manager;
         * GtkRecentInfo *info;
         * GError *error = NULL;
         *
         * manager = gtk_recent_manager_get_default ();
         * info = gtk_recent_manager_lookup_item (manager, file_uri, &error);
         * if (error)
         *   {
         *     g_warning ("Could not find the file: %s", error->message);
         *     g_error_free (error);
         *   }
         * else
         *  {
         *    // Use the info object
         *    gtk_recent_info_unref (info);
         *  }
         * ```
         *
         * In order to retrieve the list of recently used files, you can use
         * [method`Gtk`.RecentManager.get_items], which returns a list of
         * [struct`Gtk`.RecentInfo].
         *
         * Note that the maximum age of the recently used files list is
         * controllable through the [property`Gtk`.Settings:gtk-recent-files-max-age]
         * property.
         */
        class RecentManager extends GObject.Object {
            static $gtype: GObject.GType<RecentManager>;

            // Properties

            /**
             * The full path to the file to be used to store and read the
             * recently used resources list
             */
            get filename(): string;
            /**
             * The size of the recently used resources list.
             */
            get size(): number;

            // Constructors

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

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

            static ['new'](): RecentManager;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'changed', callback: (_source: this) => void): number;
            connect_after(signal: 'changed', callback: (_source: this) => void): number;
            emit(signal: 'changed'): void;

            // Static methods

            /**
             * Gets a unique instance of `GtkRecentManager` that you can share
             * in your application without caring about memory management.
             */
            static get_default(): RecentManager;

            // Virtual methods

            vfunc_changed(): void;

            // Methods

            /**
             * Adds a new resource, pointed by `uri,` into the recently used
             * resources list, using the metadata specified inside the
             * `GtkRecentData` passed in `recent_data`.
             *
             * The passed URI will be used to identify this resource inside the
             * list.
             *
             * In order to register the new recently used resource, metadata about
             * the resource must be passed as well as the URI; the metadata is
             * stored in a `GtkRecentData`, which must contain the MIME
             * type of the resource pointed by the URI; the name of the application
             * that is registering the item, and a command line to be used when
             * launching the item.
             *
             * Optionally, a `GtkRecentData` might contain a UTF-8 string
             * to be used when viewing the item instead of the last component of
             * the URI; a short description of the item; whether the item should
             * be considered private - that is, should be displayed only by the
             * applications that have registered it.
             * @param uri a valid URI
             * @param recent_data metadata of the resource
             * @returns %TRUE if the new item was successfully added to the   recently used resources list, %FALSE otherwise
             */
            add_full(uri: string, recent_data: RecentData): boolean;
            /**
             * Adds a new resource, pointed by `uri,` into the recently used
             * resources list.
             *
             * This function automatically retrieves some of the needed
             * metadata and setting other metadata to common default values;
             * it then feeds the data to [method`Gtk`.RecentManager.add_full].
             *
             * See [method`Gtk`.RecentManager.add_full] if you want to explicitly
             * define the metadata for the resource pointed by `uri`.
             * @param uri a valid URI
             * @returns %TRUE if the new item was successfully added   to the recently used resources list
             */
            add_item(uri: string): boolean;
            /**
             * Gets the list of recently used resources.
             * @returns a list of   newly allocated `GtkRecentInfo objects`. Use   [method@Gtk.RecentInfo.unref] on each item inside the list, and then   free the list itself using g_list_free().
             */
            get_items(): RecentInfo[];
            /**
             * Checks whether there is a recently used resource registered
             * with `uri` inside the recent manager.
             * @param uri a URI
             * @returns %TRUE if the resource was found, %FALSE otherwise
             */
            has_item(uri: string): boolean;
            /**
             * Searches for a URI inside the recently used resources list, and
             * returns a `GtkRecentInfo` containing information about the resource
             * like its MIME type, or its display name.
             * @param uri a URI
             * @returns a `GtkRecentInfo` containing information   about the resource pointed by @uri, or %NULL if the URI was   not registered in the recently used resources list. Free with   [method@Gtk.RecentInfo.unref].
             */
            lookup_item(uri: string): RecentInfo | null;
            /**
             * Changes the location of a recently used resource from `uri` to `new_uri`.
             *
             * Please note that this function will not affect the resource pointed
             * by the URIs, but only the URI used in the recently used resources list.
             * @param uri the URI of a recently used resource
             * @param new_uri the new URI of the recently used resource, or    %NULL to remove the item pointed by @uri in the list
             * @returns %TRUE on success
             */
            move_item(uri: string, new_uri?: string | null): boolean;
            /**
             * Purges every item from the recently used resources list.
             * @returns the number of items that have been removed from the   recently used resources list
             */
            purge_items(): number;
            /**
             * Removes a resource pointed by `uri` from the recently used resources
             * list handled by a recent manager.
             * @param uri the URI of the item you wish to remove
             * @returns %TRUE if the item pointed by @uri has been successfully   removed by the recently used resources list, and %FALSE otherwise
             */
            remove_item(uri: string): boolean;
        }

        namespace Revealer {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                child: Widget;
                child_revealed: boolean;
                childRevealed: boolean;
                reveal_child: boolean;
                revealChild: boolean;
                transition_duration: number;
                transitionDuration: number;
                transition_type: RevealerTransitionType;
                transitionType: RevealerTransitionType;
            }
        }

        /**
         * A `GtkRevealer` animates the transition of its child from invisible to visible.
         *
         * The style of transition can be controlled with
         * [method`Gtk`.Revealer.set_transition_type].
         *
         * These animations respect the [property`Gtk`.Settings:gtk-enable-animations]
         * setting.
         *
         * # CSS nodes
         *
         * `GtkRevealer` has a single CSS node with name revealer.
         * When styling `GtkRevealer` using CSS, remember that it only hides its contents,
         * not itself. That means applied margin, padding and borders will be visible even
         * when the [property`Gtk`.Revealer:reveal-child] property is set to %FALSE.
         *
         * # Accessibility
         *
         * `GtkRevealer` uses the %GTK_ACCESSIBLE_ROLE_GROUP role.
         *
         * The child of `GtkRevealer`, if set, is always available in the accessibility
         * tree, regardless of the state of the revealer widget.
         */
        class Revealer extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<Revealer>;

            // Properties

            /**
             * The child widget.
             */
            get child(): Widget;
            set child(val: Widget);
            /**
             * Whether the child is revealed and the animation target reached.
             */
            get child_revealed(): boolean;
            /**
             * Whether the child is revealed and the animation target reached.
             */
            get childRevealed(): boolean;
            /**
             * Whether the revealer should reveal the child.
             */
            get reveal_child(): boolean;
            set reveal_child(val: boolean);
            /**
             * Whether the revealer should reveal the child.
             */
            get revealChild(): boolean;
            set revealChild(val: boolean);
            /**
             * The animation duration, in milliseconds.
             */
            get transition_duration(): number;
            set transition_duration(val: number);
            /**
             * The animation duration, in milliseconds.
             */
            get transitionDuration(): number;
            set transitionDuration(val: number);
            /**
             * The type of animation used to transition.
             */
            get transition_type(): RevealerTransitionType;
            set transition_type(val: RevealerTransitionType);
            /**
             * The type of animation used to transition.
             */
            get transitionType(): RevealerTransitionType;
            set transitionType(val: RevealerTransitionType);

            // Constructors

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

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

            static ['new'](): Revealer;

            // Methods

            /**
             * Gets the child widget of `revealer`.
             * @returns the child widget of @revealer
             */
            get_child(): Widget | null;
            /**
             * Returns whether the child is fully revealed.
             *
             * In other words, this returns whether the transition
             * to the revealed state is completed.
             * @returns %TRUE if the child is fully revealed
             */
            get_child_revealed(): boolean;
            /**
             * Returns whether the child is currently revealed.
             *
             * This function returns %TRUE as soon as the transition
             * is to the revealed state is started. To learn whether
             * the child is fully revealed (ie the transition is completed),
             * use [method`Gtk`.Revealer.get_child_revealed].
             * @returns %TRUE if the child is revealed.
             */
            get_reveal_child(): boolean;
            /**
             * Returns the amount of time (in milliseconds) that
             * transitions will take.
             * @returns the transition duration
             */
            get_transition_duration(): number;
            /**
             * Gets the type of animation that will be used
             * for transitions in `revealer`.
             * @returns the current transition type of @revealer
             */
            get_transition_type(): RevealerTransitionType;
            /**
             * Sets the child widget of `revealer`.
             * @param child the child widget
             */
            set_child(child?: Widget | null): void;
            /**
             * Tells the `GtkRevealer` to reveal or conceal its child.
             *
             * The transition will be animated with the current
             * transition type of `revealer`.
             * @param reveal_child %TRUE to reveal the child
             */
            set_reveal_child(reveal_child: boolean): void;
            /**
             * Sets the duration that transitions will take.
             * @param duration the new duration, in milliseconds
             */
            set_transition_duration(duration: number): void;
            /**
             * Sets the type of animation that will be used for
             * transitions in `revealer`.
             *
             * Available types include various kinds of fades and slides.
             * @param transition the new transition type
             */
            set_transition_type(transition: RevealerTransitionType | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Scale {
            // Constructor properties interface

            interface ConstructorProps
                extends Range.ConstructorProps,
                    Accessible.ConstructorProps,
                    AccessibleRange.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Orientable.ConstructorProps {
                digits: number;
                draw_value: boolean;
                drawValue: boolean;
                has_origin: boolean;
                hasOrigin: boolean;
                value_pos: PositionType;
                valuePos: PositionType;
            }
        }

        /**
         * A `GtkScale` is a slider control used to select a numeric value.
         *
         * ![An example GtkScale](scales.png)
         *
         * To use it, you’ll probably want to investigate the methods on its base
         * class, [class`Gtk`.Range], in addition to the methods for `GtkScale` itself.
         * To set the value of a scale, you would normally use [method`Gtk`.Range.set_value].
         * To detect changes to the value, you would normally use the
         * [signal`Gtk`.Range::value-changed] signal.
         *
         * Note that using the same upper and lower bounds for the `GtkScale` (through
         * the `GtkRange` methods) will hide the slider itself. This is useful for
         * applications that want to show an undeterminate value on the scale, without
         * changing the layout of the application (such as movie or music players).
         *
         * # GtkScale as GtkBuildable
         *
         * `GtkScale` supports a custom `<marks>` element, which can contain multiple
         * `<mark\>` elements. The “value” and “position” attributes have the same
         * meaning as [method`Gtk`.Scale.add_mark] parameters of the same name. If
         * the element is not empty, its content is taken as the markup to show at
         * the mark. It can be translated with the usual ”translatable” and
         * “context” attributes.
         *
         * # Shortcuts and Gestures
         *
         * `GtkPopoverMenu` supports the following keyboard shortcuts:
         *
         * - Arrow keys, <kbd>+</kbd> and <kbd>-</kbd> will increment or decrement
         *   by step, or by page when combined with <kbd>Ctrl</kbd>.
         * - <kbd>PgUp</kbd> and <kbd>PgDn</kbd> will increment or decrement by page.
         * - <kbd>Home</kbd> and <kbd>End</kbd> will set the minimum or maximum value.
         *
         * # CSS nodes
         *
         * ```
         * scale[.fine-tune][.marks-before][.marks-after]
         * ├── [value][.top][.right][.bottom][.left]
         * ├── marks.top
         * │   ├── mark
         * │   ┊    ├── [label]
         * │   ┊    ╰── indicator
         * ┊   ┊
         * │   ╰── mark
         * ├── marks.bottom
         * │   ├── mark
         * │   ┊    ├── indicator
         * │   ┊    ╰── [label]
         * ┊   ┊
         * │   ╰── mark
         * ╰── trough
         *     ├── [fill]
         *     ├── [highlight]
         *     ╰── slider
         * ```
         *
         * `GtkScale` has a main CSS node with name scale and a subnode for its contents,
         * with subnodes named trough and slider.
         *
         * The main node gets the style class .fine-tune added when the scale is in
         * 'fine-tuning' mode.
         *
         * If the scale has an origin (see [method`Gtk`.Scale.set_has_origin]), there is
         * a subnode with name highlight below the trough node that is used for rendering
         * the highlighted part of the trough.
         *
         * If the scale is showing a fill level (see [method`Gtk`.Range.set_show_fill_level]),
         * there is a subnode with name fill below the trough node that is used for
         * rendering the filled in part of the trough.
         *
         * If marks are present, there is a marks subnode before or after the trough
         * node, below which each mark gets a node with name mark. The marks nodes get
         * either the .top or .bottom style class.
         *
         * The mark node has a subnode named indicator. If the mark has text, it also
         * has a subnode named label. When the mark is either above or left of the
         * scale, the label subnode is the first when present. Otherwise, the indicator
         * subnode is the first.
         *
         * The main CSS node gets the 'marks-before' and/or 'marks-after' style classes
         * added depending on what marks are present.
         *
         * If the scale is displaying the value (see [property`Gtk`.Scale:draw-value]),
         * there is subnode with name value. This node will get the .top or .bottom style
         * classes similar to the marks node.
         *
         * # Accessibility
         *
         * `GtkScale` uses the %GTK_ACCESSIBLE_ROLE_SLIDER role.
         */
        class Scale extends Range implements Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable {
            static $gtype: GObject.GType<Scale>;

            // Properties

            /**
             * The number of decimal places that are displayed in the value.
             */
            get digits(): number;
            set digits(val: number);
            /**
             * Whether the current value is displayed as a string next to the slider.
             */
            get draw_value(): boolean;
            set draw_value(val: boolean);
            /**
             * Whether the current value is displayed as a string next to the slider.
             */
            get drawValue(): boolean;
            set drawValue(val: boolean);
            /**
             * Whether the scale has an origin.
             */
            get has_origin(): boolean;
            set has_origin(val: boolean);
            /**
             * Whether the scale has an origin.
             */
            get hasOrigin(): boolean;
            set hasOrigin(val: boolean);
            /**
             * The position in which the current value is displayed.
             */
            get value_pos(): PositionType;
            set value_pos(val: PositionType);
            /**
             * The position in which the current value is displayed.
             */
            get valuePos(): PositionType;
            set valuePos(val: PositionType);

            // Constructors

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

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

            static ['new'](orientation: Orientation, adjustment?: Adjustment | null): Scale;

            static new_with_range(orientation: Orientation, min: number, max: number, step: number): Scale;

            // Virtual methods

            /**
             * Obtains the coordinates where the scale will draw the
             * `PangoLayout` representing the text in the scale.
             *
             * Remember when using the `PangoLayout` function you need to
             * convert to and from pixels using `PANGO_PIXELS()` or `PANGO_SCALE`.
             *
             * If the [property`Gtk`.Scale:draw-value] property is %FALSE, the return
             * values are undefined.
             */
            vfunc_get_layout_offsets(): [number, number];

            // Methods

            /**
             * Adds a mark at `value`.
             *
             * A mark is indicated visually by drawing a tick mark next to the scale,
             * and GTK makes it easy for the user to position the scale exactly at the
             * marks value.
             *
             * If `markup` is not %NULL, text is shown next to the tick mark.
             *
             * To remove marks from a scale, use [method`Gtk`.Scale.clear_marks].
             * @param value the value at which the mark is placed, must be between   the lower and upper limits of the scales’ adjustment
             * @param position where to draw the mark. For a horizontal scale, %GTK_POS_TOP   and %GTK_POS_LEFT are drawn above the scale, anything else below.   For a vertical scale, %GTK_POS_LEFT and %GTK_POS_TOP are drawn to   the left of the scale, anything else to the right.
             * @param markup Text to be shown at the mark, using Pango markup
             */
            add_mark(value: number, position: PositionType | null, markup?: string | null): void;
            /**
             * Removes any marks that have been added.
             */
            clear_marks(): void;
            /**
             * Gets the number of decimal places that are displayed in the value.
             * @returns the number of decimal places that are displayed
             */
            get_digits(): number;
            /**
             * Returns whether the current value is displayed as a string
             * next to the slider.
             * @returns whether the current value is displayed as a string
             */
            get_draw_value(): boolean;
            /**
             * Returns whether the scale has an origin.
             * @returns %TRUE if the scale has an origin.
             */
            get_has_origin(): boolean;
            /**
             * Gets the `PangoLayout` used to display the scale.
             *
             * The returned object is owned by the scale so does not need
             * to be freed by the caller.
             * @returns the [class@Pango.Layout]   for this scale, or %NULL if the [property@Gtk.Scale:draw-value]   property is %FALSE.
             */
            get_layout(): Pango.Layout | null;
            /**
             * Obtains the coordinates where the scale will draw the
             * `PangoLayout` representing the text in the scale.
             *
             * Remember when using the `PangoLayout` function you need to
             * convert to and from pixels using `PANGO_PIXELS()` or `PANGO_SCALE`.
             *
             * If the [property`Gtk`.Scale:draw-value] property is %FALSE, the return
             * values are undefined.
             */
            get_layout_offsets(): [number, number];
            /**
             * Gets the position in which the current value is displayed.
             * @returns the position in which the current value is displayed
             */
            get_value_pos(): PositionType;
            /**
             * Sets the number of decimal places that are displayed in the value.
             *
             * Also causes the value of the adjustment to be rounded to this number
             * of digits, so the retrieved value matches the displayed one, if
             * [property`Gtk`.Scale:draw-value] is %TRUE when the value changes. If
             * you want to enforce rounding the value when [property`Gtk`.Scale:draw-value]
             * is %FALSE, you can set [property`Gtk`.Range:round-digits] instead.
             *
             * Note that rounding to a small number of digits can interfere with
             * the smooth autoscrolling that is built into `GtkScale`. As an alternative,
             * you can use [method`Gtk`.Scale.set_format_value_func] to format the displayed
             * value yourself.
             * @param digits the number of decimal places to display,   e.g. use 1 to display 1.0, 2 to display 1.00, etc
             */
            set_digits(digits: number): void;
            /**
             * Specifies whether the current value is displayed as a string next
             * to the slider.
             * @param draw_value %TRUE to draw the value
             */
            set_draw_value(draw_value: boolean): void;
            /**
             * `func` allows you to change how the scale value is displayed.
             *
             * The given function will return an allocated string representing
             * `value`. That string will then be used to display the scale's value.
             *
             * If #NULL is passed as `func,` the value will be displayed on
             * its own, rounded according to the value of the
             * [property`Gtk`.Scale:digits] property.
             * @param func function   that formats the value
             * @param destroy_notify destroy function for @user_data
             */
            set_format_value_func(func?: ScaleFormatValueFunc | null, destroy_notify?: GLib.DestroyNotify | null): void;
            /**
             * Sets whether the scale has an origin.
             *
             * If [property`Gtk`.Scale:has-origin] is set to %TRUE (the default),
             * the scale will highlight the part of the trough between the origin
             * (bottom or left side) and the current value.
             * @param has_origin %TRUE if the scale has an origin
             */
            set_has_origin(has_origin: boolean): void;
            /**
             * Sets the position in which the current value is displayed.
             * @param pos the position in which the current value is displayed
             */
            set_value_pos(pos: PositionType | null): void;

            // Inherited properties
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Inherited methods
            /**
             * Sets the current value of the accessible range.
             *
             * This operation should behave similarly as if the user performed the
             * action.
             * @param value the value to set
             */
            vfunc_set_current_value(value: number): boolean;
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ScaleButton {
            // Signal callback interfaces

            interface Popdown {
                (): void;
            }

            interface Popup {
                (): void;
            }

            interface ValueChanged {
                (value: number): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    AccessibleRange.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Orientable.ConstructorProps {
                active: boolean;
                adjustment: Adjustment;
                has_frame: boolean;
                hasFrame: boolean;
                icons: string[];
                value: number;
            }
        }

        /**
         * `GtkScaleButton` provides a button which pops up a scale widget.
         *
         * This kind of widget is commonly used for volume controls in multimedia
         * applications, and GTK provides a [class`Gtk`.VolumeButton] subclass that
         * is tailored for this use case.
         *
         * # Shortcuts and Gestures
         *
         * The following signals have default keybindings:
         *
         * - [signal`Gtk`.ScaleButton::popup]
         *
         * # CSS nodes
         *
         * ```
         * scalebutton.scale
         * ╰── button.toggle
         *     ╰── <icon>
         * ```
         *
         * `GtkScaleButton` has a single CSS node with name scalebutton and `.scale`
         * style class, and contains a `button` node with a `.toggle` style class.
         */
        class ScaleButton
            extends Widget
            implements Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable
        {
            static $gtype: GObject.GType<ScaleButton>;

            // Properties

            /**
             * If the scale button should be pressed in.
             */
            get active(): boolean;
            /**
             * The `GtkAdjustment` that is used as the model.
             */
            get adjustment(): Adjustment;
            set adjustment(val: Adjustment);
            /**
             * If the scale button has a frame.
             */
            get has_frame(): boolean;
            set has_frame(val: boolean);
            /**
             * If the scale button has a frame.
             */
            get hasFrame(): boolean;
            set hasFrame(val: boolean);
            /**
             * The names of the icons to be used by the scale button.
             *
             * The first item in the array will be used in the button
             * when the current value is the lowest value, the second
             * item for the highest value. All the subsequent icons will
             * be used for all the other values, spread evenly over the
             * range of values.
             *
             * If there's only one icon name in the `icons` array, it will
             * be used for all the values. If only two icon names are in
             * the `icons` array, the first one will be used for the bottom
             * 50% of the scale, and the second one for the top 50%.
             *
             * It is recommended to use at least 3 icons so that the
             * `GtkScaleButton` reflects the current value of the scale
             * better for the users.
             */
            get icons(): string[];
            set icons(val: string[]);
            /**
             * The value of the scale.
             */
            get value(): number;
            set value(val: number);

            // Constructors

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

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

            static ['new'](min: number, max: number, step: number, icons?: string[] | null): ScaleButton;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'popdown', callback: (_source: this) => void): number;
            connect_after(signal: 'popdown', callback: (_source: this) => void): number;
            emit(signal: 'popdown'): void;
            connect(signal: 'popup', callback: (_source: this) => void): number;
            connect_after(signal: 'popup', callback: (_source: this) => void): number;
            emit(signal: 'popup'): void;
            connect(signal: 'value-changed', callback: (_source: this, value: number) => void): number;
            connect_after(signal: 'value-changed', callback: (_source: this, value: number) => void): number;
            emit(signal: 'value-changed', value: number): void;

            // Virtual methods

            vfunc_value_changed(value: number): void;

            // Methods

            /**
             * Queries a `GtkScaleButton` and returns its current state.
             *
             * Returns %TRUE if the scale button is pressed in and %FALSE
             * if it is raised.
             * @returns whether the button is pressed
             */
            get_active(): boolean;
            /**
             * Gets the `GtkAdjustment` associated with the `GtkScaleButton`’s scale.
             *
             * See [method`Gtk`.Range.get_adjustment] for details.
             * @returns the adjustment associated with the scale
             */
            get_adjustment(): Adjustment;
            /**
             * Returns whether the button has a frame.
             * @returns %TRUE if the button has a frame
             */
            get_has_frame(): boolean;
            /**
             * Retrieves the minus button of the `GtkScaleButton`.
             * @returns the minus button   of the `GtkScaleButton`
             */
            get_minus_button(): Button;
            /**
             * Retrieves the plus button of the `GtkScaleButton.`
             * @returns the plus button   of the `GtkScaleButton`
             */
            get_plus_button(): Button;
            /**
             * Retrieves the popup of the `GtkScaleButton`.
             * @returns the popup of the `GtkScaleButton`
             */
            get_popup(): Widget;
            /**
             * Gets the current value of the scale button.
             * @returns current value of the scale button
             */
            get_value(): number;
            /**
             * Sets the `GtkAdjustment` to be used as a model
             * for the `GtkScaleButton`’s scale.
             *
             * See [method`Gtk`.Range.set_adjustment] for details.
             * @param adjustment a `GtkAdjustment`
             */
            set_adjustment(adjustment: Adjustment): void;
            /**
             * Sets the style of the button.
             * @param has_frame whether the button should have a visible frame
             */
            set_has_frame(has_frame: boolean): void;
            /**
             * Sets the icons to be used by the scale button.
             * @param icons a %NULL-terminated array of icon names
             */
            set_icons(icons: string[]): void;
            /**
             * Sets the current value of the scale.
             *
             * If the value is outside the minimum or maximum range values,
             * it will be clamped to fit inside them.
             *
             * The scale button emits the [signal`Gtk`.ScaleButton::value-changed]
             * signal if the value changes.
             * @param value new value of the scale button
             */
            set_value(value: number): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Sets the current value of the accessible range.
             *
             * This operation should behave similarly as if the user performed the
             * action.
             * @param value the value to set
             */
            vfunc_set_current_value(value: number): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Scrollbar {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    AccessibleRange.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Orientable.ConstructorProps {
                adjustment: Adjustment;
            }
        }

        /**
         * The `GtkScrollbar` widget is a horizontal or vertical scrollbar.
         *
         * ![An example GtkScrollbar](scrollbar.png)
         *
         * Its position and movement are controlled by the adjustment that is passed to
         * or created by [ctor`Gtk`.Scrollbar.new]. See [class`Gtk`.Adjustment] for more
         * details. The [property`Gtk`.Adjustment:value] field sets the position of the
         * thumb and must be between [property`Gtk`.Adjustment:lower] and
         * [property`Gtk`.Adjustment:upper] - [property`Gtk`.Adjustment:page-size].
         * The [property`Gtk`.Adjustment:page-size] represents the size of the visible
         * scrollable area.
         *
         * The fields [property`Gtk`.Adjustment:step-increment] and
         * [property`Gtk`.Adjustment:page-increment] fields are added to or subtracted
         * from the [property`Gtk`.Adjustment:value] when the user asks to move by a step
         * (using e.g. the cursor arrow keys) or by a page (using e.g. the Page Down/Up
         * keys).
         *
         * # CSS nodes
         *
         * ```
         * scrollbar
         * ╰── range[.fine-tune]
         *     ╰── trough
         *         ╰── slider
         * ```
         *
         * `GtkScrollbar` has a main CSS node with name scrollbar and a subnode for its
         * contents. The main node gets the .horizontal or .vertical style classes applied,
         * depending on the scrollbar's orientation.
         *
         * The range node gets the style class .fine-tune added when the scrollbar is
         * in 'fine-tuning' mode.
         *
         * Other style classes that may be added to scrollbars inside
         * [class`Gtk`.ScrolledWindow] include the positional classes (.left, .right,
         * .top, .bottom) and style classes related to overlay scrolling (.overlay-indicator,
         * .dragging, .hovering).
         *
         * # Accessibility
         *
         * `GtkScrollbar` uses the %GTK_ACCESSIBLE_ROLE_SCROLLBAR role.
         */
        class Scrollbar extends Widget implements Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable {
            static $gtype: GObject.GType<Scrollbar>;

            // Properties

            /**
             * The `GtkAdjustment` controlled by this scrollbar.
             */
            get adjustment(): Adjustment;
            set adjustment(val: Adjustment);

            // Constructors

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

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

            static ['new'](orientation: Orientation, adjustment?: Adjustment | null): Scrollbar;

            // Methods

            /**
             * Returns the scrollbar's adjustment.
             * @returns the scrollbar's adjustment
             */
            get_adjustment(): Adjustment;
            /**
             * Makes the scrollbar use the given adjustment.
             * @param adjustment the adjustment to set
             */
            set_adjustment(adjustment?: Adjustment | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Sets the current value of the accessible range.
             *
             * This operation should behave similarly as if the user performed the
             * action.
             * @param value the value to set
             */
            vfunc_set_current_value(value: number): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ScrolledWindow {
            // Signal callback interfaces

            interface EdgeOvershot {
                (pos: PositionType): void;
            }

            interface EdgeReached {
                (pos: PositionType): void;
            }

            interface MoveFocusOut {
                (direction_type: DirectionType): void;
            }

            interface ScrollChild {
                (scroll: ScrollType, horizontal: boolean): boolean;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                child: Widget;
                hadjustment: Adjustment;
                has_frame: boolean;
                hasFrame: boolean;
                hscrollbar_policy: PolicyType;
                hscrollbarPolicy: PolicyType;
                kinetic_scrolling: boolean;
                kineticScrolling: boolean;
                max_content_height: number;
                maxContentHeight: number;
                max_content_width: number;
                maxContentWidth: number;
                min_content_height: number;
                minContentHeight: number;
                min_content_width: number;
                minContentWidth: number;
                overlay_scrolling: boolean;
                overlayScrolling: boolean;
                propagate_natural_height: boolean;
                propagateNaturalHeight: boolean;
                propagate_natural_width: boolean;
                propagateNaturalWidth: boolean;
                vadjustment: Adjustment;
                vscrollbar_policy: PolicyType;
                vscrollbarPolicy: PolicyType;
                window_placement: CornerType;
                windowPlacement: CornerType;
            }
        }

        /**
         * `GtkScrolledWindow` is a container that makes its child scrollable.
         *
         * It does so using either internally added scrollbars or externally
         * associated adjustments, and optionally draws a frame around the child.
         *
         * Widgets with native scrolling support, i.e. those whose classes implement
         * the [iface`Gtk`.Scrollable] interface, are added directly. For other types
         * of widget, the class [class`Gtk`.Viewport] acts as an adaptor, giving
         * scrollability to other widgets. [method`Gtk`.ScrolledWindow.set_child]
         * intelligently accounts for whether or not the added child is a `GtkScrollable`.
         * If it isn’t, then it wraps the child in a `GtkViewport`. Therefore, you can
         * just add any child widget and not worry about the details.
         *
         * If [method`Gtk`.ScrolledWindow.set_child] has added a `GtkViewport` for you,
         * it will be automatically removed when you unset the child.
         * Unless [property`Gtk`.ScrolledWindow:hscrollbar-policy] and
         * [property`Gtk`.ScrolledWindow:vscrollbar-policy] are %GTK_POLICY_NEVER or
         * %GTK_POLICY_EXTERNAL, `GtkScrolledWindow` adds internal `GtkScrollbar` widgets
         * around its child. The scroll position of the child, and if applicable the
         * scrollbars, is controlled by the [property`Gtk`.ScrolledWindow:hadjustment]
         * and [property`Gtk`.ScrolledWindow:vadjustment] that are associated with the
         * `GtkScrolledWindow`. See the docs on [class`Gtk`.Scrollbar] for the details,
         * but note that the “step_increment” and “page_increment” fields are only
         * effective if the policy causes scrollbars to be present.
         *
         * If a `GtkScrolledWindow` doesn’t behave quite as you would like, or
         * doesn’t have exactly the right layout, it’s very possible to set up
         * your own scrolling with `GtkScrollbar` and for example a `GtkGrid`.
         *
         * # Touch support
         *
         * `GtkScrolledWindow` has built-in support for touch devices. When a
         * touchscreen is used, swiping will move the scrolled window, and will
         * expose 'kinetic' behavior. This can be turned off with the
         * [property`Gtk`.ScrolledWindow:kinetic-scrolling] property if it is undesired.
         *
         * `GtkScrolledWindow` also displays visual 'overshoot' indication when
         * the content is pulled beyond the end, and this situation can be
         * captured with the [signal`Gtk`.ScrolledWindow::edge-overshot] signal.
         *
         * If no mouse device is present, the scrollbars will overlaid as
         * narrow, auto-hiding indicators over the content. If traditional
         * scrollbars are desired although no mouse is present, this behaviour
         * can be turned off with the [property`Gtk`.ScrolledWindow:overlay-scrolling]
         * property.
         *
         * # Shortcuts and Gestures
         *
         * The following signals have default keybindings:
         *
         * - [signal`Gtk`.ScrolledWindow::scroll-child]
         *
         * # CSS nodes
         *
         * `GtkScrolledWindow` has a main CSS node with name scrolledwindow.
         * It gets a .frame style class added when [property`Gtk`.ScrolledWindow:has-frame]
         * is %TRUE.
         *
         * It uses subnodes with names overshoot and undershoot to draw the overflow
         * and underflow indications. These nodes get the .left, .right, .top or .bottom
         * style class added depending on where the indication is drawn.
         *
         * `GtkScrolledWindow` also sets the positional style classes (.left, .right,
         * .top, .bottom) and style classes related to overlay scrolling
         * (.overlay-indicator, .dragging, .hovering) on its scrollbars.
         *
         * If both scrollbars are visible, the area where they meet is drawn
         * with a subnode named junction.
         *
         * # Accessibility
         *
         * Until GTK 4.10, `GtkScrolledWindow` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
         *
         * Starting from GTK 4.12, `GtkScrolledWindow` uses the `GTK_ACCESSIBLE_ROLE_GENERIC` role.
         */
        class ScrolledWindow extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<ScrolledWindow>;

            // Properties

            /**
             * The child widget.
             *
             * When setting this property, if the child widget does not implement
             * [iface`Gtk`.Scrollable], the scrolled window will add the child to
             * a [class`Gtk`.Viewport] and then set the viewport as the child.
             */
            get child(): Widget;
            set child(val: Widget);
            /**
             * The `GtkAdjustment` for the horizontal position.
             */
            get hadjustment(): Adjustment;
            set hadjustment(val: Adjustment);
            /**
             * Whether to draw a frame around the contents.
             */
            get has_frame(): boolean;
            set has_frame(val: boolean);
            /**
             * Whether to draw a frame around the contents.
             */
            get hasFrame(): boolean;
            set hasFrame(val: boolean);
            /**
             * When the horizontal scrollbar is displayed.
             *
             * Use [method`Gtk`.ScrolledWindow.set_policy] to set
             * this property.
             */
            get hscrollbar_policy(): PolicyType;
            set hscrollbar_policy(val: PolicyType);
            /**
             * When the horizontal scrollbar is displayed.
             *
             * Use [method`Gtk`.ScrolledWindow.set_policy] to set
             * this property.
             */
            get hscrollbarPolicy(): PolicyType;
            set hscrollbarPolicy(val: PolicyType);
            /**
             * Whether kinetic scrolling is enabled or not.
             *
             * Kinetic scrolling only applies to devices with source %GDK_SOURCE_TOUCHSCREEN.
             */
            get kinetic_scrolling(): boolean;
            set kinetic_scrolling(val: boolean);
            /**
             * Whether kinetic scrolling is enabled or not.
             *
             * Kinetic scrolling only applies to devices with source %GDK_SOURCE_TOUCHSCREEN.
             */
            get kineticScrolling(): boolean;
            set kineticScrolling(val: boolean);
            /**
             * The maximum content height of `scrolled_window`.
             */
            get max_content_height(): number;
            set max_content_height(val: number);
            /**
             * The maximum content height of `scrolled_window`.
             */
            get maxContentHeight(): number;
            set maxContentHeight(val: number);
            /**
             * The maximum content width of `scrolled_window`.
             */
            get max_content_width(): number;
            set max_content_width(val: number);
            /**
             * The maximum content width of `scrolled_window`.
             */
            get maxContentWidth(): number;
            set maxContentWidth(val: number);
            /**
             * The minimum content height of `scrolled_window`.
             */
            get min_content_height(): number;
            set min_content_height(val: number);
            /**
             * The minimum content height of `scrolled_window`.
             */
            get minContentHeight(): number;
            set minContentHeight(val: number);
            /**
             * The minimum content width of `scrolled_window`.
             */
            get min_content_width(): number;
            set min_content_width(val: number);
            /**
             * The minimum content width of `scrolled_window`.
             */
            get minContentWidth(): number;
            set minContentWidth(val: number);
            /**
             * Whether overlay scrolling is enabled or not.
             *
             * If it is, the scrollbars are only added as traditional widgets
             * when a mouse is present. Otherwise, they are overlaid on top of
             * the content, as narrow indicators.
             *
             * Note that overlay scrolling can also be globally disabled, with
             * the [property`Gtk`.Settings:gtk-overlay-scrolling] setting.
             */
            get overlay_scrolling(): boolean;
            set overlay_scrolling(val: boolean);
            /**
             * Whether overlay scrolling is enabled or not.
             *
             * If it is, the scrollbars are only added as traditional widgets
             * when a mouse is present. Otherwise, they are overlaid on top of
             * the content, as narrow indicators.
             *
             * Note that overlay scrolling can also be globally disabled, with
             * the [property`Gtk`.Settings:gtk-overlay-scrolling] setting.
             */
            get overlayScrolling(): boolean;
            set overlayScrolling(val: boolean);
            /**
             * Whether the natural height of the child should be calculated and propagated
             * through the scrolled window’s requested natural height.
             *
             * This is useful in cases where an attempt should be made to allocate exactly
             * enough space for the natural size of the child.
             */
            get propagate_natural_height(): boolean;
            set propagate_natural_height(val: boolean);
            /**
             * Whether the natural height of the child should be calculated and propagated
             * through the scrolled window’s requested natural height.
             *
             * This is useful in cases where an attempt should be made to allocate exactly
             * enough space for the natural size of the child.
             */
            get propagateNaturalHeight(): boolean;
            set propagateNaturalHeight(val: boolean);
            /**
             * Whether the natural width of the child should be calculated and propagated
             * through the scrolled window’s requested natural width.
             *
             * This is useful in cases where an attempt should be made to allocate exactly
             * enough space for the natural size of the child.
             */
            get propagate_natural_width(): boolean;
            set propagate_natural_width(val: boolean);
            /**
             * Whether the natural width of the child should be calculated and propagated
             * through the scrolled window’s requested natural width.
             *
             * This is useful in cases where an attempt should be made to allocate exactly
             * enough space for the natural size of the child.
             */
            get propagateNaturalWidth(): boolean;
            set propagateNaturalWidth(val: boolean);
            /**
             * The `GtkAdjustment` for the vertical position.
             */
            get vadjustment(): Adjustment;
            set vadjustment(val: Adjustment);
            /**
             * When the vertical scrollbar is displayed.
             *
             * Use [method`Gtk`.ScrolledWindow.set_policy] to set
             * this property.
             */
            get vscrollbar_policy(): PolicyType;
            set vscrollbar_policy(val: PolicyType);
            /**
             * When the vertical scrollbar is displayed.
             *
             * Use [method`Gtk`.ScrolledWindow.set_policy] to set
             * this property.
             */
            get vscrollbarPolicy(): PolicyType;
            set vscrollbarPolicy(val: PolicyType);
            /**
             * Where the contents are located with respect to the scrollbars.
             */
            get window_placement(): CornerType;
            set window_placement(val: CornerType);
            /**
             * Where the contents are located with respect to the scrollbars.
             */
            get windowPlacement(): CornerType;
            set windowPlacement(val: CornerType);

            // Constructors

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

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

            static ['new'](): ScrolledWindow;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'edge-overshot', callback: (_source: this, pos: PositionType) => void): number;
            connect_after(signal: 'edge-overshot', callback: (_source: this, pos: PositionType) => void): number;
            emit(signal: 'edge-overshot', pos: PositionType): void;
            connect(signal: 'edge-reached', callback: (_source: this, pos: PositionType) => void): number;
            connect_after(signal: 'edge-reached', callback: (_source: this, pos: PositionType) => void): number;
            emit(signal: 'edge-reached', pos: PositionType): void;
            connect(signal: 'move-focus-out', callback: (_source: this, direction_type: DirectionType) => void): number;
            connect_after(
                signal: 'move-focus-out',
                callback: (_source: this, direction_type: DirectionType) => void,
            ): number;
            emit(signal: 'move-focus-out', direction_type: DirectionType): void;
            connect(
                signal: 'scroll-child',
                callback: (_source: this, scroll: ScrollType, horizontal: boolean) => boolean,
            ): number;
            connect_after(
                signal: 'scroll-child',
                callback: (_source: this, scroll: ScrollType, horizontal: boolean) => boolean,
            ): number;
            emit(signal: 'scroll-child', scroll: ScrollType, horizontal: boolean): void;

            // Methods

            /**
             * Gets the child widget of `scrolled_window`.
             *
             * If the scrolled window automatically added a [class`Gtk`.Viewport], this
             * function will return the viewport widget, and you can retrieve its child
             * using [method`Gtk`.Viewport.get_child].
             * @returns the child widget of @scrolled_window
             */
            get_child(): Widget | null;
            /**
             * Returns the horizontal scrollbar’s adjustment.
             *
             * This is the adjustment used to connect the horizontal scrollbar
             * to the child widget’s horizontal scroll functionality.
             * @returns the horizontal `GtkAdjustment`
             */
            get_hadjustment(): Adjustment;
            /**
             * Gets whether the scrolled window draws a frame.
             * @returns %TRUE if the @scrolled_window has a frame
             */
            get_has_frame(): boolean;
            /**
             * Returns the horizontal scrollbar of `scrolled_window`.
             * @returns the horizontal scrollbar of the scrolled window.
             */
            get_hscrollbar(): Widget;
            /**
             * Returns the specified kinetic scrolling behavior.
             * @returns the scrolling behavior flags.
             */
            get_kinetic_scrolling(): boolean;
            /**
             * Returns the maximum content height set.
             * @returns the maximum content height, or -1
             */
            get_max_content_height(): number;
            /**
             * Returns the maximum content width set.
             * @returns the maximum content width, or -1
             */
            get_max_content_width(): number;
            /**
             * Gets the minimal content height of `scrolled_window`.
             * @returns the minimal content height
             */
            get_min_content_height(): number;
            /**
             * Gets the minimum content width of `scrolled_window`.
             * @returns the minimum content width
             */
            get_min_content_width(): number;
            /**
             * Returns whether overlay scrolling is enabled for this scrolled window.
             * @returns %TRUE if overlay scrolling is enabled
             */
            get_overlay_scrolling(): boolean;
            /**
             * Gets the placement of the contents with respect to the scrollbars.
             * @returns the current placement value.
             */
            get_placement(): CornerType;
            /**
             * Retrieves the current policy values for the horizontal and vertical
             * scrollbars.
             *
             * See [method`Gtk`.ScrolledWindow.set_policy].
             */
            get_policy(): [PolicyType | null, PolicyType | null];
            /**
             * Reports whether the natural height of the child will be calculated
             * and propagated through the scrolled window’s requested natural height.
             * @returns whether natural height propagation is enabled.
             */
            get_propagate_natural_height(): boolean;
            /**
             * Reports whether the natural width of the child will be calculated
             * and propagated through the scrolled window’s requested natural width.
             * @returns whether natural width propagation is enabled.
             */
            get_propagate_natural_width(): boolean;
            /**
             * Returns the vertical scrollbar’s adjustment.
             *
             * This is the adjustment used to connect the vertical
             * scrollbar to the child widget’s vertical scroll functionality.
             * @returns the vertical `GtkAdjustment`
             */
            get_vadjustment(): Adjustment;
            /**
             * Returns the vertical scrollbar of `scrolled_window`.
             * @returns the vertical scrollbar of the scrolled window.
             */
            get_vscrollbar(): Widget;
            /**
             * Sets the child widget of `scrolled_window`.
             *
             * If `child` does not implement the [iface`Gtk`.Scrollable] interface,
             * the scrolled window will add `child` to a [class`Gtk`.Viewport] instance
             * and then add the viewport as its child widget.
             * @param child the child widget
             */
            set_child(child?: Widget | null): void;
            /**
             * Sets the `GtkAdjustment` for the horizontal scrollbar.
             * @param hadjustment the `GtkAdjustment` to use, or %NULL to create a new one
             */
            set_hadjustment(hadjustment?: Adjustment | null): void;
            /**
             * Changes the frame drawn around the contents of `scrolled_window`.
             * @param has_frame whether to draw a frame around scrolled window contents
             */
            set_has_frame(has_frame: boolean): void;
            /**
             * Turns kinetic scrolling on or off.
             *
             * Kinetic scrolling only applies to devices with source
             * %GDK_SOURCE_TOUCHSCREEN.
             * @param kinetic_scrolling %TRUE to enable kinetic scrolling
             */
            set_kinetic_scrolling(kinetic_scrolling: boolean): void;
            /**
             * Sets the maximum height that `scrolled_window` should keep visible.
             *
             * The `scrolled_window` will grow up to this height before it starts
             * scrolling the content.
             *
             * It is a programming error to set the maximum content height to a value
             * smaller than [property`Gtk`.ScrolledWindow:min-content-height].
             * @param height the maximum content height
             */
            set_max_content_height(height: number): void;
            /**
             * Sets the maximum width that `scrolled_window` should keep visible.
             *
             * The `scrolled_window` will grow up to this width before it starts
             * scrolling the content.
             *
             * It is a programming error to set the maximum content width to a
             * value smaller than [property`Gtk`.ScrolledWindow:min-content-width].
             * @param width the maximum content width
             */
            set_max_content_width(width: number): void;
            /**
             * Sets the minimum height that `scrolled_window` should keep visible.
             *
             * Note that this can and (usually will) be smaller than the minimum
             * size of the content.
             *
             * It is a programming error to set the minimum content height to a
             * value greater than [property`Gtk`.ScrolledWindow:max-content-height].
             * @param height the minimal content height
             */
            set_min_content_height(height: number): void;
            /**
             * Sets the minimum width that `scrolled_window` should keep visible.
             *
             * Note that this can and (usually will) be smaller than the minimum
             * size of the content.
             *
             * It is a programming error to set the minimum content width to a
             * value greater than [property`Gtk`.ScrolledWindow:max-content-width].
             * @param width the minimal content width
             */
            set_min_content_width(width: number): void;
            /**
             * Enables or disables overlay scrolling for this scrolled window.
             * @param overlay_scrolling whether to enable overlay scrolling
             */
            set_overlay_scrolling(overlay_scrolling: boolean): void;
            /**
             * Sets the placement of the contents with respect to the scrollbars
             * for the scrolled window.
             *
             * The default is %GTK_CORNER_TOP_LEFT, meaning the child is
             * in the top left, with the scrollbars underneath and to the right.
             * Other values in [enum`Gtk`.CornerType] are %GTK_CORNER_TOP_RIGHT,
             * %GTK_CORNER_BOTTOM_LEFT, and %GTK_CORNER_BOTTOM_RIGHT.
             *
             * See also [method`Gtk`.ScrolledWindow.get_placement] and
             * [method`Gtk`.ScrolledWindow.unset_placement].
             * @param window_placement position of the child window
             */
            set_placement(window_placement: CornerType | null): void;
            /**
             * Sets the scrollbar policy for the horizontal and vertical scrollbars.
             *
             * The policy determines when the scrollbar should appear; it is a value
             * from the [enum`Gtk`.PolicyType] enumeration. If %GTK_POLICY_ALWAYS, the
             * scrollbar is always present; if %GTK_POLICY_NEVER, the scrollbar is
             * never present; if %GTK_POLICY_AUTOMATIC, the scrollbar is present only
             * if needed (that is, if the slider part of the bar would be smaller
             * than the trough — the display is larger than the page size).
             * @param hscrollbar_policy policy for horizontal bar
             * @param vscrollbar_policy policy for vertical bar
             */
            set_policy(hscrollbar_policy: PolicyType | null, vscrollbar_policy: PolicyType | null): void;
            /**
             * Sets whether the natural height of the child should be calculated
             * and propagated through the scrolled window’s requested natural height.
             * @param propagate whether to propagate natural height
             */
            set_propagate_natural_height(propagate: boolean): void;
            /**
             * Sets whether the natural width of the child should be calculated
             * and propagated through the scrolled window’s requested natural width.
             * @param propagate whether to propagate natural width
             */
            set_propagate_natural_width(propagate: boolean): void;
            /**
             * Sets the `GtkAdjustment` for the vertical scrollbar.
             * @param vadjustment the `GtkAdjustment` to use, or %NULL to create a new one
             */
            set_vadjustment(vadjustment?: Adjustment | null): void;
            /**
             * Unsets the placement of the contents with respect to the scrollbars.
             *
             * If no window placement is set for a scrolled window,
             * it defaults to %GTK_CORNER_TOP_LEFT.
             */
            unset_placement(): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace SearchBar {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                child: Widget;
                key_capture_widget: Widget;
                keyCaptureWidget: Widget;
                search_mode_enabled: boolean;
                searchModeEnabled: boolean;
                show_close_button: boolean;
                showCloseButton: boolean;
            }
        }

        /**
         * `GtkSearchBar` is a container made to have a search entry.
         *
         * ![An example GtkSearchBar](search-bar.png)
         *
         * It can also contain additional widgets, such as drop-down menus,
         * or buttons.  The search bar would appear when a search is started
         * through typing on the keyboard, or the application’s search mode
         * is toggled on.
         *
         * For keyboard presses to start a search, the search bar must be told
         * of a widget to capture key events from through
         * [method`Gtk`.SearchBar.set_key_capture_widget]. This widget will
         * typically be the top-level window, or a parent container of the
         * search bar. Common shortcuts such as Ctrl+F should be handled as an
         * application action, or through the menu items.
         *
         * You will also need to tell the search bar about which entry you
         * are using as your search entry using [method`Gtk`.SearchBar.connect_entry].
         *
         * ## Creating a search bar
         *
         * The following example shows you how to create a more complex search
         * entry.
         *
         * [A simple example](https://gitlab.gnome.org/GNOME/gtk/tree/main/examples/search-bar.c)
         *
         * # Shortcuts and Gestures
         *
         * `GtkSearchBar` supports the following keyboard shortcuts:
         *
         * - <kbd>Escape</kbd> hides the search bar.
         *
         * # CSS nodes
         *
         * ```
         * searchbar
         * ╰── revealer
         *     ╰── box
         *          ├── [child]
         *          ╰── [button.close]
         * ```
         *
         * `GtkSearchBar` has a main CSS node with name searchbar. It has a child
         * node with name revealer that contains a node with name box. The box node
         * contains both the CSS node of the child widget as well as an optional button
         * node which gets the .close style class applied.
         *
         * # Accessibility
         *
         * `GtkSearchBar` uses the %GTK_ACCESSIBLE_ROLE_SEARCH role.
         */
        class SearchBar extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<SearchBar>;

            // Properties

            /**
             * The child widget.
             */
            get child(): Widget;
            set child(val: Widget);
            /**
             * The key capture widget.
             */
            get key_capture_widget(): Widget;
            set key_capture_widget(val: Widget);
            /**
             * The key capture widget.
             */
            get keyCaptureWidget(): Widget;
            set keyCaptureWidget(val: Widget);
            /**
             * Whether the search mode is on and the search bar shown.
             */
            get search_mode_enabled(): boolean;
            set search_mode_enabled(val: boolean);
            /**
             * Whether the search mode is on and the search bar shown.
             */
            get searchModeEnabled(): boolean;
            set searchModeEnabled(val: boolean);
            /**
             * Whether to show the close button in the search bar.
             */
            get show_close_button(): boolean;
            set show_close_button(val: boolean);
            /**
             * Whether to show the close button in the search bar.
             */
            get showCloseButton(): boolean;
            set showCloseButton(val: boolean);

            // Constructors

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

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

            static ['new'](): SearchBar;

            // Methods

            /**
             * Connects the `GtkEditable` widget passed as the one to be used in
             * this search bar.
             *
             * The entry should be a descendant of the search bar. Calling this
             * function manually is only required if the entry isn’t the direct
             * child of the search bar (as in our main example).
             * @param entry a `GtkEditable`
             */
            connect_entry(entry: Editable): void;
            /**
             * Gets the child widget of `bar`.
             * @returns the child widget of @bar
             */
            get_child(): Widget | null;
            /**
             * Gets the widget that `bar` is capturing key events from.
             * @returns The key capture widget.
             */
            get_key_capture_widget(): Widget | null;
            /**
             * Returns whether the search mode is on or off.
             * @returns whether search mode is toggled on
             */
            get_search_mode(): boolean;
            /**
             * Returns whether the close button is shown.
             * @returns whether the close button is shown
             */
            get_show_close_button(): boolean;
            /**
             * Sets the child widget of `bar`.
             * @param child the child widget
             */
            set_child(child?: Widget | null): void;
            /**
             * Sets `widget` as the widget that `bar` will capture key events
             * from.
             *
             * If key events are handled by the search bar, the bar will
             * be shown, and the entry populated with the entered text.
             *
             * Note that despite the name of this function, the events
             * are only 'captured' in the bubble phase, which means that
             * editable child widgets of `widget` will receive text input
             * before it gets captured. If that is not desired, you can
             * capture and forward the events yourself with
             * [method`Gtk`.EventControllerKey.forward].
             * @param widget a `GtkWidget`
             */
            set_key_capture_widget(widget?: Widget | null): void;
            /**
             * Switches the search mode on or off.
             * @param search_mode the new state of the search mode
             */
            set_search_mode(search_mode: boolean): void;
            /**
             * Shows or hides the close button.
             *
             * Applications that already have a “search” toggle button should not
             * show a close button in their search bar, as it duplicates the role
             * of the toggle button.
             * @param visible whether the close button will be shown or not
             */
            set_show_close_button(visible: boolean): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace SearchEntry {
            // Signal callback interfaces

            interface Activate {
                (): void;
            }

            interface NextMatch {
                (): void;
            }

            interface PreviousMatch {
                (): void;
            }

            interface SearchChanged {
                (): void;
            }

            interface SearchStarted {
                (): void;
            }

            interface StopSearch {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Editable.ConstructorProps {
                activates_default: boolean;
                activatesDefault: boolean;
                input_hints: InputHints;
                inputHints: InputHints;
                input_purpose: InputPurpose;
                inputPurpose: InputPurpose;
                placeholder_text: string;
                placeholderText: string;
                search_delay: number;
                searchDelay: number;
            }
        }

        /**
         * `GtkSearchEntry` is an entry widget that has been tailored for use
         * as a search entry.
         *
         * The main API for interacting with a `GtkSearchEntry` as entry
         * is the `GtkEditable` interface.
         *
         * ![An example GtkSearchEntry](search-entry.png)
         *
         * It will show an inactive symbolic “find” icon when the search
         * entry is empty, and a symbolic “clear” icon when there is text.
         * Clicking on the “clear” icon will empty the search entry.
         *
         * To make filtering appear more reactive, it is a good idea to
         * not react to every change in the entry text immediately, but
         * only after a short delay. To support this, `GtkSearchEntry`
         * emits the [signal`Gtk`.SearchEntry::search-changed] signal which
         * can be used instead of the [signal`Gtk`.Editable::changed] signal.
         *
         * The [signal`Gtk`.SearchEntry::previous-match],
         * [signal`Gtk`.SearchEntry::next-match] and
         * [signal`Gtk`.SearchEntry::stop-search] signals can be used to
         * implement moving between search results and ending the search.
         *
         * Often, `GtkSearchEntry` will be fed events by means of being
         * placed inside a [class`Gtk`.SearchBar]. If that is not the case,
         * you can use [method`Gtk`.SearchEntry.set_key_capture_widget] to
         * let it capture key input from another widget.
         *
         * `GtkSearchEntry` provides only minimal API and should be used with
         * the [iface`Gtk`.Editable] API.
         *
         * ## Shortcuts and Gestures
         *
         * The following signals have default keybindings:
         *
         * - [signal`Gtk`.SearchEntry::activate]
         * - [signal`Gtk`.SearchEntry::next-match]
         * - [signal`Gtk`.SearchEntry::previous-match]
         * - [signal`Gtk`.SearchEntry::stop-search]
         *
         * ## CSS Nodes
         *
         * ```
         * entry.search
         * ╰── text
         * ```
         *
         * `GtkSearchEntry` has a single CSS node with name entry that carries
         * a `.search` style class, and the text node is a child of that.
         *
         * ## Accessibility
         *
         * `GtkSearchEntry` uses the %GTK_ACCESSIBLE_ROLE_SEARCH_BOX role.
         */
        class SearchEntry extends Widget implements Accessible, Buildable, ConstraintTarget, Editable {
            static $gtype: GObject.GType<SearchEntry>;

            // Properties

            /**
             * Whether to activate the default widget when Enter is pressed.
             */
            get activates_default(): boolean;
            set activates_default(val: boolean);
            /**
             * Whether to activate the default widget when Enter is pressed.
             */
            get activatesDefault(): boolean;
            set activatesDefault(val: boolean);
            /**
             * The hints about input for the `GtkSearchEntry` used to alter the
             * behaviour of input methods.
             */
            get input_hints(): InputHints;
            set input_hints(val: InputHints);
            /**
             * The hints about input for the `GtkSearchEntry` used to alter the
             * behaviour of input methods.
             */
            get inputHints(): InputHints;
            set inputHints(val: InputHints);
            /**
             * The purpose for the `GtkSearchEntry` input used to alter the
             * behaviour of input methods.
             */
            get input_purpose(): InputPurpose;
            set input_purpose(val: InputPurpose);
            /**
             * The purpose for the `GtkSearchEntry` input used to alter the
             * behaviour of input methods.
             */
            get inputPurpose(): InputPurpose;
            set inputPurpose(val: InputPurpose);
            /**
             * The text that will be displayed in the `GtkSearchEntry`
             * when it is empty and unfocused.
             */
            get placeholder_text(): string;
            set placeholder_text(val: string);
            /**
             * The text that will be displayed in the `GtkSearchEntry`
             * when it is empty and unfocused.
             */
            get placeholderText(): string;
            set placeholderText(val: string);
            /**
             * The delay in milliseconds from last keypress to the search
             * changed signal.
             */
            get search_delay(): number;
            set search_delay(val: number);
            /**
             * The delay in milliseconds from last keypress to the search
             * changed signal.
             */
            get searchDelay(): number;
            set searchDelay(val: number);

            // Constructors

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

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

            static ['new'](): SearchEntry;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate', callback: (_source: this) => void): number;
            connect_after(signal: 'activate', callback: (_source: this) => void): number;
            emit(signal: 'activate'): void;
            connect(signal: 'next-match', callback: (_source: this) => void): number;
            connect_after(signal: 'next-match', callback: (_source: this) => void): number;
            emit(signal: 'next-match'): void;
            connect(signal: 'previous-match', callback: (_source: this) => void): number;
            connect_after(signal: 'previous-match', callback: (_source: this) => void): number;
            emit(signal: 'previous-match'): void;
            connect(signal: 'search-changed', callback: (_source: this) => void): number;
            connect_after(signal: 'search-changed', callback: (_source: this) => void): number;
            emit(signal: 'search-changed'): void;
            connect(signal: 'search-started', callback: (_source: this) => void): number;
            connect_after(signal: 'search-started', callback: (_source: this) => void): number;
            emit(signal: 'search-started'): void;
            connect(signal: 'stop-search', callback: (_source: this) => void): number;
            connect_after(signal: 'stop-search', callback: (_source: this) => void): number;
            emit(signal: 'stop-search'): void;

            // Methods

            /**
             * Gets the input purpose for `entry`.
             * @returns The input hints
             */
            get_input_hints(): InputHints;
            /**
             * Gets the input purpose of `entry`.
             * @returns The input hints
             */
            get_input_purpose(): InputPurpose;
            /**
             * Gets the widget that `entry` is capturing key events from.
             * @returns The key capture widget.
             */
            get_key_capture_widget(): Widget | null;
            /**
             * Gets the placeholder text associated with `entry`.
             * @returns The placeholder text.
             */
            get_placeholder_text(): string | null;
            /**
             * Get the delay to be used between the last keypress and the
             * [signal`Gtk`.SearchEntry::search-changed] signal being emitted.
             * @returns a delay in milliseconds.
             */
            get_search_delay(): number;
            /**
             * Sets the input hints for `entry`.
             * @param hints the new input hints
             */
            set_input_hints(hints: InputHints | null): void;
            /**
             * Sets the input purpose of `entry`.
             * @param purpose the new input purpose
             */
            set_input_purpose(purpose: InputPurpose | null): void;
            /**
             * Sets `widget` as the widget that `entry` will capture key
             * events from.
             *
             * Key events are consumed by the search entry to start or
             * continue a search.
             *
             * If the entry is part of a `GtkSearchBar`, it is preferable
             * to call [method`Gtk`.SearchBar.set_key_capture_widget] instead,
             * which will reveal the entry in addition to triggering the
             * search entry.
             *
             * Note that despite the name of this function, the events
             * are only 'captured' in the bubble phase, which means that
             * editable child widgets of `widget` will receive text input
             * before it gets captured. If that is not desired, you can
             * capture and forward the events yourself with
             * [method`Gtk`.EventControllerKey.forward].
             * @param widget a `GtkWidget`
             */
            set_key_capture_widget(widget?: Widget | null): void;
            /**
             * Sets the placeholder text associated with `entry`.
             * @param text the text to set as a placeholder
             */
            set_placeholder_text(text?: string | null): void;
            /**
             * Set the delay to be used between the last keypress and the
             * [signal`Gtk`.SearchEntry::search-changed] signal being emitted.
             * @param delay a delay in milliseconds
             */
            set_search_delay(delay: number): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The current position of the insertion cursor in chars.
             */
            get cursor_position(): number;
            /**
             * The current position of the insertion cursor in chars.
             */
            get cursorPosition(): number;
            /**
             * Whether the entry contents can be edited.
             */
            get editable(): boolean;
            set editable(val: boolean);
            /**
             * If undo/redo should be enabled for the editable.
             */
            get enable_undo(): boolean;
            set enable_undo(val: boolean);
            /**
             * If undo/redo should be enabled for the editable.
             */
            get enableUndo(): boolean;
            set enableUndo(val: boolean);
            /**
             * The desired maximum width of the entry, in characters.
             */
            get max_width_chars(): number;
            set max_width_chars(val: number);
            /**
             * The desired maximum width of the entry, in characters.
             */
            get maxWidthChars(): number;
            set maxWidthChars(val: number);
            /**
             * The position of the opposite end of the selection from the cursor in chars.
             */
            get selection_bound(): number;
            /**
             * The position of the opposite end of the selection from the cursor in chars.
             */
            get selectionBound(): number;
            /**
             * The contents of the entry.
             */
            get text(): string;
            set text(val: string);
            /**
             * Number of characters to leave space for in the entry.
             */
            get width_chars(): number;
            set width_chars(val: number);
            /**
             * Number of characters to leave space for in the entry.
             */
            get widthChars(): number;
            set widthChars(val: number);
            /**
             * The horizontal alignment, from 0 (left) to 1 (right).
             *
             * Reversed for RTL layouts.
             */
            get xalign(): number;
            set xalign(val: number);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Retrieves the accessible platform state from the editable delegate.
             *
             * This is an helper function to retrieve the accessible state for
             * `GtkEditable` interface implementations using a delegate pattern.
             *
             * You should call this function in your editable widget implementation
             * of the [vfunc`Gtk`.Accessible.get_platform_state] virtual function, for
             * instance:
             *
             * ```c
             * static void
             * accessible_interface_init (GtkAccessibleInterface *iface)
             * {
             *   iface->get_platform_state = your_editable_get_accessible_platform_state;
             * }
             *
             * static gboolean
             * your_editable_get_accessible_platform_state (GtkAccessible *accessible,
             *                                              GtkAccessiblePlatformState state)
             * {
             *   return gtk_editable_delegate_get_accessible_platform_state (GTK_EDITABLE (accessible), state);
             * }
             * ```
             *
             * Note that the widget which is the delegate *must* be a direct child of
             * this widget, otherwise your implementation of [vfunc`Gtk`.Accessible.get_platform_state]
             * might not even be called, as the platform change will originate from
             * the parent of the delegate, and, as a result, will not work properly.
             *
             * So, if you can't ensure the direct child condition, you should give the
             * delegate the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role, or you can
             * change your tree to allow this function to work.
             * @param state what kind of accessible state to retrieve
             * @returns the accessible platform state of the delegate
             */
            delegate_get_accessible_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Deletes the currently selected text of the editable.
             *
             * This call doesn’t do anything if there is no selected text.
             */
            delete_selection(): void;
            /**
             * Deletes a sequence of characters.
             *
             * The characters that are deleted are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters deleted are those from `start_pos` to
             * the end of the text.
             *
             * Note that the positions are specified in characters, not bytes.
             * @param start_pos start position
             * @param end_pos end position
             */
            delete_text(start_pos: number, end_pos: number): void;
            /**
             * Undoes the setup done by [method`Gtk`.Editable.init_delegate].
             *
             * This is a helper function that should be called from dispose,
             * before removing the delegate object.
             */
            finish_delegate(): void;
            /**
             * Gets the alignment of the editable.
             * @returns the alignment
             */
            get_alignment(): number;
            /**
             * Retrieves a sequence of characters.
             *
             * The characters that are retrieved are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is negative,
             * then the characters retrieved are those characters from `start_pos` to
             * the end of the text.
             *
             * Note that positions are specified in characters, not bytes.
             * @param start_pos start of text
             * @param end_pos end of text
             * @returns a pointer to the contents of the widget as a   string. This string is allocated by the `GtkEditable` implementation   and should be freed by the caller.
             */
            get_chars(start_pos: number, end_pos: number): string;
            /**
             * Gets the `GtkEditable` that `editable` is delegating its
             * implementation to.
             *
             * Typically, the delegate is a [class`Gtk`.Text] widget.
             * @returns the delegate `GtkEditable`
             */
            get_delegate(): Editable | null;
            /**
             * Retrieves whether `editable` is editable.
             * @returns %TRUE if @editable is editable.
             */
            get_editable(): boolean;
            /**
             * Gets if undo/redo actions are enabled for `editable`
             * @returns %TRUE if undo is enabled
             */
            get_enable_undo(): boolean;
            /**
             * Retrieves the desired maximum width of `editable,` in characters.
             * @returns the maximum width of the entry, in characters
             */
            get_max_width_chars(): number;
            /**
             * Retrieves the current position of the cursor relative
             * to the start of the content of the editable.
             *
             * Note that this position is in characters, not in bytes.
             * @returns the cursor position
             */
            get_position(): number;
            /**
             * Retrieves the selection bound of the editable.
             *
             * `start_pos` will be filled with the start of the selection and
             * `end_pos` with end. If no text was selected both will be identical
             * and %FALSE will be returned.
             *
             * Note that positions are specified in characters, not bytes.
             * @returns %TRUE if there is a non-empty selection, %FALSE otherwise
             */
            get_selection_bounds(): [boolean, number, number];
            /**
             * Retrieves the contents of `editable`.
             *
             * The returned string is owned by GTK and must not be modified or freed.
             * @returns a pointer to the contents of the editable
             */
            get_text(): string;
            /**
             * Gets the number of characters of space reserved
             * for the contents of the editable.
             * @returns number of chars to request space for, or negative if unset
             */
            get_width_chars(): number;
            /**
             * Sets up a delegate for `GtkEditable`.
             *
             * This is assuming that the get_delegate vfunc in the `GtkEditable`
             * interface has been set up for the `editable'`s type.
             *
             * This is a helper function that should be called in instance init,
             * after creating the delegate object.
             */
            init_delegate(): void;
            /**
             * Inserts `length` bytes of `text` into the contents of the
             * widget, at position `position`.
             *
             * Note that the position is in characters, not in bytes.
             * The function updates `position` to point after the newly
             * inserted text.
             * @param text the text to insert
             * @param length the length of the text in bytes, or -1
             * @param position location of the position text will be inserted at
             */
            insert_text(text: string, length: number, position: number): number;
            /**
             * Selects a region of text.
             *
             * The characters that are selected are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters selected are those characters from
             * `start_pos` to  the end of the text.
             *
             * Note that positions are specified in characters, not bytes.
             * @param start_pos start of region
             * @param end_pos end of region
             */
            select_region(start_pos: number, end_pos: number): void;
            /**
             * Sets the alignment for the contents of the editable.
             *
             * This controls the horizontal positioning of the contents when
             * the displayed text is shorter than the width of the editable.
             * @param xalign The horizontal alignment, from 0 (left) to 1 (right).   Reversed for RTL layouts
             */
            set_alignment(xalign: number): void;
            /**
             * Determines if the user can edit the text in the editable widget.
             * @param is_editable %TRUE if the user is allowed to edit the text   in the widget
             */
            set_editable(is_editable: boolean): void;
            /**
             * If enabled, changes to `editable` will be saved for undo/redo
             * actions.
             *
             * This results in an additional copy of text changes and are not
             * stored in secure memory. As such, undo is forcefully disabled
             * when [property`Gtk`.Text:visibility] is set to %FALSE.
             * @param enable_undo if undo/redo should be enabled
             */
            set_enable_undo(enable_undo: boolean): void;
            /**
             * Sets the desired maximum width in characters of `editable`.
             * @param n_chars the new desired maximum width, in characters
             */
            set_max_width_chars(n_chars: number): void;
            /**
             * Sets the cursor position in the editable to the given value.
             *
             * The cursor is displayed before the character with the given (base 0)
             * index in the contents of the editable. The value must be less than
             * or equal to the number of characters in the editable. A value of -1
             * indicates that the position should be set after the last character
             * of the editable. Note that `position` is in characters, not in bytes.
             * @param position the position of the cursor
             */
            set_position(position: number): void;
            /**
             * Sets the text in the editable to the given value.
             *
             * This is replacing the current contents.
             * @param text the text to set
             */
            set_text(text: string): void;
            /**
             * Changes the size request of the editable to be about the
             * right size for `n_chars` characters.
             *
             * Note that it changes the size request, the size can still
             * be affected by how you pack the widget into containers.
             * If `n_chars` is -1, the size reverts to the default size.
             * @param n_chars width in chars
             */
            set_width_chars(n_chars: number): void;
            vfunc_changed(): void;
            /**
             * Deletes a sequence of characters.
             *
             * The characters that are deleted are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters deleted are those from `start_pos` to
             * the end of the text.
             *
             * Note that the positions are specified in characters, not bytes.
             * @param start_pos start position
             * @param end_pos end position
             */
            vfunc_delete_text(start_pos: number, end_pos: number): void;
            /**
             * Deletes a sequence of characters.
             *
             * The characters that are deleted are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters deleted are those from `start_pos` to
             * the end of the text.
             *
             * Note that the positions are specified in characters, not bytes.
             * @param start_pos start position
             * @param end_pos end position
             */
            vfunc_do_delete_text(start_pos: number, end_pos: number): void;
            /**
             * Inserts `length` bytes of `text` into the contents of the
             * widget, at position `position`.
             *
             * Note that the position is in characters, not in bytes.
             * The function updates `position` to point after the newly
             * inserted text.
             * @param text the text to insert
             * @param length the length of the text in bytes, or -1
             * @param position location of the position text will be inserted at
             */
            vfunc_do_insert_text(text: string, length: number, position: number): number;
            /**
             * Gets the `GtkEditable` that `editable` is delegating its
             * implementation to.
             *
             * Typically, the delegate is a [class`Gtk`.Text] widget.
             */
            vfunc_get_delegate(): Editable | null;
            /**
             * Retrieves the selection bound of the editable.
             *
             * `start_pos` will be filled with the start of the selection and
             * `end_pos` with end. If no text was selected both will be identical
             * and %FALSE will be returned.
             *
             * Note that positions are specified in characters, not bytes.
             */
            vfunc_get_selection_bounds(): [boolean, number, number];
            /**
             * Retrieves the contents of `editable`.
             *
             * The returned string is owned by GTK and must not be modified or freed.
             */
            vfunc_get_text(): string;
            /**
             * Inserts `length` bytes of `text` into the contents of the
             * widget, at position `position`.
             *
             * Note that the position is in characters, not in bytes.
             * The function updates `position` to point after the newly
             * inserted text.
             * @param text the text to insert
             * @param length the length of the text in bytes, or -1
             * @param position location of the position text will be inserted at
             */
            vfunc_insert_text(text: string, length: number, position: number): number;
            /**
             * Selects a region of text.
             *
             * The characters that are selected are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters selected are those characters from
             * `start_pos` to  the end of the text.
             *
             * Note that positions are specified in characters, not bytes.
             * @param start_pos start of region
             * @param end_pos end of region
             */
            vfunc_set_selection_bounds(start_pos: number, end_pos: number): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace SelectionFilterModel {
            // Constructor properties interface

            interface ConstructorProps<A extends GObject.Object = GObject.Object>
                extends GObject.Object.ConstructorProps,
                    Gio.ListModel.ConstructorProps {
                item_type: GObject.GType;
                itemType: GObject.GType;
                model: SelectionModel;
                n_items: number;
                nItems: number;
            }
        }

        /**
         * `GtkSelectionFilterModel` is a list model that presents the selection from
         * a `GtkSelectionModel`.
         */
        class SelectionFilterModel<A extends GObject.Object = GObject.Object>
            extends GObject.Object
            implements Gio.ListModel<A>
        {
            static $gtype: GObject.GType<SelectionFilterModel>;

            // Properties

            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get item_type(): GObject.GType;
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get itemType(): GObject.GType;
            /**
             * The model being filtered.
             */
            get model(): SelectionModel;
            set model(val: SelectionModel);
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get n_items(): number;
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get nItems(): number;

            // Constructors

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

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

            static ['new'](model?: SelectionModel | null): SelectionFilterModel;

            // Methods

            /**
             * Gets the model currently filtered or %NULL if none.
             * @returns The model that gets filtered
             */
            get_model(): SelectionModel | null;
            /**
             * Sets the model to be filtered.
             *
             * Note that GTK makes no effort to ensure that `model` conforms to
             * the item type of `self`. It assumes that the caller knows what they
             * are doing and have set up an appropriate filter to ensure that item
             * types match.
             * @param model The model to be filtered
             */
            set_model(model?: SelectionModel | null): void;

            // Inherited methods
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             * @returns the #GType of the items contained in @list.
             */
            get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             * @returns the number of items in @list.
             */
            get_n_items(): number;
            /**
             * Get the item at `position`.
             *
             * If `position` is greater than the number of items in `list,` %NULL is
             * returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.
             *
             * This function is meant to be used by language bindings in place
             * of g_list_model_get_item().
             *
             * See also: g_list_model_get_n_items()
             * @param position the position of the item to fetch
             * @returns the object at @position.
             */
            get_item(position: number): A | null;
            /**
             * Emits the #GListModel::items-changed signal on `list`.
             *
             * This function should only be called by classes implementing
             * #GListModel. It has to be called after the internal representation
             * of `list` has been updated, because handlers connected to this signal
             * might query the new state of the list.
             *
             * Implementations must only make changes to the model (as visible to
             * its consumer) in places that will not cause problems for that
             * consumer.  For models that are driven directly by a write API (such
             * as #GListStore), changes can be reported in response to uses of that
             * API.  For models that represent remote data, changes should only be
             * made from a fresh mainloop dispatch.  It is particularly not
             * permitted to make changes in response to a call to the #GListModel
             * consumer API.
             *
             * Stated another way: in general, it is assumed that code making a
             * series of accesses to the model via the API, without returning to the
             * mainloop, and without calling other code, will continue to view the
             * same contents of the model.
             * @param position the position at which @list changed
             * @param removed the number of items removed
             * @param added the number of items added
             */
            items_changed(position: number, removed: number, added: number): void;
            /**
             * Get the item at `position`. If `position` is greater than the number of
             * items in `list,` %NULL is returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.  See g_list_model_get_n_items().
             *
             * The same #GObject instance may not appear more than once in a #GListModel.
             * @param position the position of the item to fetch
             */
            vfunc_get_item(position: number): A | null;
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             */
            vfunc_get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             */
            vfunc_get_n_items(): number;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Separator {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Orientable.ConstructorProps {}
        }

        /**
         * `GtkSeparator` is a horizontal or vertical separator widget.
         *
         * ![An example GtkSeparator](separator.png)
         *
         * A `GtkSeparator` can be used to group the widgets within a window.
         * It displays a line with a shadow to make it appear sunken into the
         * interface.
         *
         * # CSS nodes
         *
         * `GtkSeparator` has a single CSS node with name separator. The node
         * gets one of the .horizontal or .vertical style classes.
         *
         * # Accessibility
         *
         * `GtkSeparator` uses the %GTK_ACCESSIBLE_ROLE_SEPARATOR role.
         */
        class Separator extends Widget implements Accessible, Buildable, ConstraintTarget, Orientable {
            static $gtype: GObject.GType<Separator>;

            // Constructors

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

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

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

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Settings {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps, StyleProvider.ConstructorProps {
                gtk_alternative_button_order: boolean;
                gtkAlternativeButtonOrder: boolean;
                gtk_alternative_sort_arrows: boolean;
                gtkAlternativeSortArrows: boolean;
                gtk_application_prefer_dark_theme: boolean;
                gtkApplicationPreferDarkTheme: boolean;
                gtk_cursor_aspect_ratio: number;
                gtkCursorAspectRatio: number;
                gtk_cursor_blink: boolean;
                gtkCursorBlink: boolean;
                gtk_cursor_blink_time: number;
                gtkCursorBlinkTime: number;
                gtk_cursor_blink_timeout: number;
                gtkCursorBlinkTimeout: number;
                gtk_cursor_theme_name: string;
                gtkCursorThemeName: string;
                gtk_cursor_theme_size: number;
                gtkCursorThemeSize: number;
                gtk_decoration_layout: string;
                gtkDecorationLayout: string;
                gtk_dialogs_use_header: boolean;
                gtkDialogsUseHeader: boolean;
                gtk_dnd_drag_threshold: number;
                gtkDndDragThreshold: number;
                gtk_double_click_distance: number;
                gtkDoubleClickDistance: number;
                gtk_double_click_time: number;
                gtkDoubleClickTime: number;
                gtk_enable_accels: boolean;
                gtkEnableAccels: boolean;
                gtk_enable_animations: boolean;
                gtkEnableAnimations: boolean;
                gtk_enable_event_sounds: boolean;
                gtkEnableEventSounds: boolean;
                gtk_enable_input_feedback_sounds: boolean;
                gtkEnableInputFeedbackSounds: boolean;
                gtk_enable_primary_paste: boolean;
                gtkEnablePrimaryPaste: boolean;
                gtk_entry_password_hint_timeout: number;
                gtkEntryPasswordHintTimeout: number;
                gtk_entry_select_on_focus: boolean;
                gtkEntrySelectOnFocus: boolean;
                gtk_error_bell: boolean;
                gtkErrorBell: boolean;
                gtk_font_name: string;
                gtkFontName: string;
                gtk_font_rendering: FontRendering;
                gtkFontRendering: FontRendering;
                gtk_fontconfig_timestamp: number;
                gtkFontconfigTimestamp: number;
                gtk_hint_font_metrics: boolean;
                gtkHintFontMetrics: boolean;
                gtk_icon_theme_name: string;
                gtkIconThemeName: string;
                gtk_im_module: string;
                gtkImModule: string;
                gtk_keynav_use_caret: boolean;
                gtkKeynavUseCaret: boolean;
                gtk_label_select_on_focus: boolean;
                gtkLabelSelectOnFocus: boolean;
                gtk_long_press_time: number;
                gtkLongPressTime: number;
                gtk_overlay_scrolling: boolean;
                gtkOverlayScrolling: boolean;
                gtk_primary_button_warps_slider: boolean;
                gtkPrimaryButtonWarpsSlider: boolean;
                gtk_print_backends: string;
                gtkPrintBackends: string;
                gtk_print_preview_command: string;
                gtkPrintPreviewCommand: string;
                gtk_recent_files_enabled: boolean;
                gtkRecentFilesEnabled: boolean;
                gtk_recent_files_max_age: number;
                gtkRecentFilesMaxAge: number;
                gtk_shell_shows_app_menu: boolean;
                gtkShellShowsAppMenu: boolean;
                gtk_shell_shows_desktop: boolean;
                gtkShellShowsDesktop: boolean;
                gtk_shell_shows_menubar: boolean;
                gtkShellShowsMenubar: boolean;
                gtk_show_status_shapes: boolean;
                gtkShowStatusShapes: boolean;
                gtk_sound_theme_name: string;
                gtkSoundThemeName: string;
                gtk_split_cursor: boolean;
                gtkSplitCursor: boolean;
                gtk_theme_name: string;
                gtkThemeName: string;
                gtk_titlebar_double_click: string;
                gtkTitlebarDoubleClick: string;
                gtk_titlebar_middle_click: string;
                gtkTitlebarMiddleClick: string;
                gtk_titlebar_right_click: string;
                gtkTitlebarRightClick: string;
                gtk_xft_antialias: number;
                gtkXftAntialias: number;
                gtk_xft_dpi: number;
                gtkXftDpi: number;
                gtk_xft_hinting: number;
                gtkXftHinting: number;
                gtk_xft_hintstyle: string;
                gtkXftHintstyle: string;
                gtk_xft_rgba: string;
                gtkXftRgba: string;
            }
        }

        /**
         * `GtkSettings` provides a mechanism to share global settings between
         * applications.
         *
         * On the X window system, this sharing is realized by an
         * [XSettings](http://www.freedesktop.org/wiki/Specifications/xsettings-spec)
         * manager that is usually part of the desktop environment, along with
         * utilities that let the user change these settings.
         *
         * On Wayland, the settings are obtained either via a settings portal,
         * or by reading desktop settings from [class`Gio`.Settings].
         *
         * On macOS, the settings are obtained from `NSUserDefaults`.
         *
         * In the absence of these sharing mechanisms, GTK reads default values for
         * settings from `settings.ini` files in `/etc/gtk-4.0`, `$XDG_CONFIG_DIRS/gtk-4.0`
         * and `$XDG_CONFIG_HOME/gtk-4.0`. These files must be valid key files (see
         * `GKeyFile`), and have a section called Settings. Themes can also provide
         * default values for settings by installing a `settings.ini` file
         * next to their `gtk.css` file.
         *
         * Applications can override system-wide settings by setting the property
         * of the `GtkSettings` object with g_object_set(). This should be restricted
         * to special cases though; `GtkSettings` are not meant as an application
         * configuration facility.
         *
         * There is one `GtkSettings` instance per display. It can be obtained with
         * [func`Gtk`.Settings.get_for_display], but in many cases, it is more
         * convenient to use [method`Gtk`.Widget.get_settings].
         */
        class Settings extends GObject.Object implements StyleProvider {
            static $gtype: GObject.GType<Settings>;

            // Properties

            /**
             * Whether buttons in dialogs should use the alternative button order.
             */
            get gtk_alternative_button_order(): boolean;
            set gtk_alternative_button_order(val: boolean);
            /**
             * Whether buttons in dialogs should use the alternative button order.
             */
            get gtkAlternativeButtonOrder(): boolean;
            set gtkAlternativeButtonOrder(val: boolean);
            /**
             * Controls the direction of the sort indicators in sorted list and tree
             * views.
             *
             * By default an arrow pointing down means the column is sorted
             * in ascending order. When set to %TRUE, this order will be inverted.
             */
            get gtk_alternative_sort_arrows(): boolean;
            set gtk_alternative_sort_arrows(val: boolean);
            /**
             * Controls the direction of the sort indicators in sorted list and tree
             * views.
             *
             * By default an arrow pointing down means the column is sorted
             * in ascending order. When set to %TRUE, this order will be inverted.
             */
            get gtkAlternativeSortArrows(): boolean;
            set gtkAlternativeSortArrows(val: boolean);
            /**
             * Whether the application prefers to use a dark theme.
             *
             * If a GTK theme includes a dark variant, it will be used
             * instead of the configured theme.
             *
             * Some applications benefit from minimizing the amount of light
             * pollution that interferes with the content. Good candidates for
             * dark themes are photo and video editors that make the actual
             * content get all the attention and minimize the distraction of
             * the chrome.
             *
             * Dark themes should not be used for documents, where large spaces
             * are white/light and the dark chrome creates too much contrast
             * (web browser, text editor...).
             */
            get gtk_application_prefer_dark_theme(): boolean;
            set gtk_application_prefer_dark_theme(val: boolean);
            /**
             * Whether the application prefers to use a dark theme.
             *
             * If a GTK theme includes a dark variant, it will be used
             * instead of the configured theme.
             *
             * Some applications benefit from minimizing the amount of light
             * pollution that interferes with the content. Good candidates for
             * dark themes are photo and video editors that make the actual
             * content get all the attention and minimize the distraction of
             * the chrome.
             *
             * Dark themes should not be used for documents, where large spaces
             * are white/light and the dark chrome creates too much contrast
             * (web browser, text editor...).
             */
            get gtkApplicationPreferDarkTheme(): boolean;
            set gtkApplicationPreferDarkTheme(val: boolean);
            /**
             * The aspect ratio of the text caret.
             */
            get gtk_cursor_aspect_ratio(): number;
            set gtk_cursor_aspect_ratio(val: number);
            /**
             * The aspect ratio of the text caret.
             */
            get gtkCursorAspectRatio(): number;
            set gtkCursorAspectRatio(val: number);
            /**
             * Whether the cursor should blink.
             *
             * Also see the [property`Gtk`.Settings:gtk-cursor-blink-timeout] setting,
             * which allows more flexible control over cursor blinking.
             */
            get gtk_cursor_blink(): boolean;
            set gtk_cursor_blink(val: boolean);
            /**
             * Whether the cursor should blink.
             *
             * Also see the [property`Gtk`.Settings:gtk-cursor-blink-timeout] setting,
             * which allows more flexible control over cursor blinking.
             */
            get gtkCursorBlink(): boolean;
            set gtkCursorBlink(val: boolean);
            /**
             * Length of the cursor blink cycle, in milliseconds.
             */
            get gtk_cursor_blink_time(): number;
            set gtk_cursor_blink_time(val: number);
            /**
             * Length of the cursor blink cycle, in milliseconds.
             */
            get gtkCursorBlinkTime(): number;
            set gtkCursorBlinkTime(val: number);
            /**
             * Time after which the cursor stops blinking, in seconds.
             *
             * The timer is reset after each user interaction.
             *
             * Setting this to zero has the same effect as setting
             * [property`Gtk`.Settings:gtk-cursor-blink] to %FALSE.
             */
            get gtk_cursor_blink_timeout(): number;
            set gtk_cursor_blink_timeout(val: number);
            /**
             * Time after which the cursor stops blinking, in seconds.
             *
             * The timer is reset after each user interaction.
             *
             * Setting this to zero has the same effect as setting
             * [property`Gtk`.Settings:gtk-cursor-blink] to %FALSE.
             */
            get gtkCursorBlinkTimeout(): number;
            set gtkCursorBlinkTimeout(val: number);
            /**
             * Name of the cursor theme to use.
             *
             * Use %NULL to use the default theme.
             */
            get gtk_cursor_theme_name(): string;
            set gtk_cursor_theme_name(val: string);
            /**
             * Name of the cursor theme to use.
             *
             * Use %NULL to use the default theme.
             */
            get gtkCursorThemeName(): string;
            set gtkCursorThemeName(val: string);
            /**
             * The size to use for cursors.
             *
             * 0 means to use the default size.
             */
            get gtk_cursor_theme_size(): number;
            set gtk_cursor_theme_size(val: number);
            /**
             * The size to use for cursors.
             *
             * 0 means to use the default size.
             */
            get gtkCursorThemeSize(): number;
            set gtkCursorThemeSize(val: number);
            /**
             * Determines which buttons should be put in the
             * titlebar of client-side decorated windows, and whether they
             * should be placed on the left or right.
             *
             * The format of the string is button names, separated by commas.
             * A colon separates the buttons that should appear on the left
             * from those on the right. Recognized button names are minimize,
             * maximize, close, icon (the window icon) and menu (a menu button
             * for the fallback app menu).
             *
             * For example, "menu:minimize,maximize,close" specifies a menu
             * on the left, and minimize, maximize and close buttons on the right.
             *
             * Note that buttons will only be shown when they are meaningful.
             * E.g. a menu button only appears when the desktop shell does not
             * show the app menu, and a close button only appears on a window
             * that can be closed.
             *
             * Also note that the setting can be overridden with the
             * [property`Gtk`.HeaderBar:decoration-layout] property.
             */
            get gtk_decoration_layout(): string;
            set gtk_decoration_layout(val: string);
            /**
             * Determines which buttons should be put in the
             * titlebar of client-side decorated windows, and whether they
             * should be placed on the left or right.
             *
             * The format of the string is button names, separated by commas.
             * A colon separates the buttons that should appear on the left
             * from those on the right. Recognized button names are minimize,
             * maximize, close, icon (the window icon) and menu (a menu button
             * for the fallback app menu).
             *
             * For example, "menu:minimize,maximize,close" specifies a menu
             * on the left, and minimize, maximize and close buttons on the right.
             *
             * Note that buttons will only be shown when they are meaningful.
             * E.g. a menu button only appears when the desktop shell does not
             * show the app menu, and a close button only appears on a window
             * that can be closed.
             *
             * Also note that the setting can be overridden with the
             * [property`Gtk`.HeaderBar:decoration-layout] property.
             */
            get gtkDecorationLayout(): string;
            set gtkDecorationLayout(val: string);
            /**
             * Whether builtin GTK dialogs such as the file chooser, the
             * color chooser or the font chooser will use a header bar at
             * the top to show action widgets, or an action area at the bottom.
             *
             * This setting does not affect custom dialogs using `GtkDialog`
             * directly, or message dialogs.
             */
            get gtk_dialogs_use_header(): boolean;
            set gtk_dialogs_use_header(val: boolean);
            /**
             * Whether builtin GTK dialogs such as the file chooser, the
             * color chooser or the font chooser will use a header bar at
             * the top to show action widgets, or an action area at the bottom.
             *
             * This setting does not affect custom dialogs using `GtkDialog`
             * directly, or message dialogs.
             */
            get gtkDialogsUseHeader(): boolean;
            set gtkDialogsUseHeader(val: boolean);
            /**
             * The number of pixels the cursor can move before dragging.
             */
            get gtk_dnd_drag_threshold(): number;
            set gtk_dnd_drag_threshold(val: number);
            /**
             * The number of pixels the cursor can move before dragging.
             */
            get gtkDndDragThreshold(): number;
            set gtkDndDragThreshold(val: number);
            /**
             * The maximum distance allowed between two clicks for them to be considered
             * a double click, in pixels.
             */
            get gtk_double_click_distance(): number;
            set gtk_double_click_distance(val: number);
            /**
             * The maximum distance allowed between two clicks for them to be considered
             * a double click, in pixels.
             */
            get gtkDoubleClickDistance(): number;
            set gtkDoubleClickDistance(val: number);
            /**
             * The maximum time to allow between two clicks for them to be considered
             * a double click, in milliseconds.
             */
            get gtk_double_click_time(): number;
            set gtk_double_click_time(val: number);
            /**
             * The maximum time to allow between two clicks for them to be considered
             * a double click, in milliseconds.
             */
            get gtkDoubleClickTime(): number;
            set gtkDoubleClickTime(val: number);
            /**
             * Whether menu items should have visible accelerators which can be
             * activated.
             */
            get gtk_enable_accels(): boolean;
            set gtk_enable_accels(val: boolean);
            /**
             * Whether menu items should have visible accelerators which can be
             * activated.
             */
            get gtkEnableAccels(): boolean;
            set gtkEnableAccels(val: boolean);
            /**
             * Whether to enable toolkit-wide animations.
             */
            get gtk_enable_animations(): boolean;
            set gtk_enable_animations(val: boolean);
            /**
             * Whether to enable toolkit-wide animations.
             */
            get gtkEnableAnimations(): boolean;
            set gtkEnableAnimations(val: boolean);
            /**
             * Whether to play any event sounds at all.
             *
             * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
             * for more information on event sounds and sound themes.
             *
             * GTK itself does not support event sounds, you have to use a loadable
             * module like the one that comes with libcanberra.
             */
            get gtk_enable_event_sounds(): boolean;
            set gtk_enable_event_sounds(val: boolean);
            /**
             * Whether to play any event sounds at all.
             *
             * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
             * for more information on event sounds and sound themes.
             *
             * GTK itself does not support event sounds, you have to use a loadable
             * module like the one that comes with libcanberra.
             */
            get gtkEnableEventSounds(): boolean;
            set gtkEnableEventSounds(val: boolean);
            /**
             * Whether to play event sounds as feedback to user input.
             *
             * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
             * for more information on event sounds and sound themes.
             *
             * GTK itself does not support event sounds, you have to use a loadable
             * module like the one that comes with libcanberra.
             */
            get gtk_enable_input_feedback_sounds(): boolean;
            set gtk_enable_input_feedback_sounds(val: boolean);
            /**
             * Whether to play event sounds as feedback to user input.
             *
             * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
             * for more information on event sounds and sound themes.
             *
             * GTK itself does not support event sounds, you have to use a loadable
             * module like the one that comes with libcanberra.
             */
            get gtkEnableInputFeedbackSounds(): boolean;
            set gtkEnableInputFeedbackSounds(val: boolean);
            /**
             * Whether a middle click on a mouse should paste the
             * 'PRIMARY' clipboard content at the cursor location.
             */
            get gtk_enable_primary_paste(): boolean;
            set gtk_enable_primary_paste(val: boolean);
            /**
             * Whether a middle click on a mouse should paste the
             * 'PRIMARY' clipboard content at the cursor location.
             */
            get gtkEnablePrimaryPaste(): boolean;
            set gtkEnablePrimaryPaste(val: boolean);
            /**
             * How long to show the last input character in hidden
             * entries.
             *
             * This value is in milliseconds. 0 disables showing the
             * last char. 600 is a good value for enabling it.
             */
            get gtk_entry_password_hint_timeout(): number;
            set gtk_entry_password_hint_timeout(val: number);
            /**
             * How long to show the last input character in hidden
             * entries.
             *
             * This value is in milliseconds. 0 disables showing the
             * last char. 600 is a good value for enabling it.
             */
            get gtkEntryPasswordHintTimeout(): number;
            set gtkEntryPasswordHintTimeout(val: number);
            /**
             * Whether to select the contents of an entry when it is focused.
             */
            get gtk_entry_select_on_focus(): boolean;
            set gtk_entry_select_on_focus(val: boolean);
            /**
             * Whether to select the contents of an entry when it is focused.
             */
            get gtkEntrySelectOnFocus(): boolean;
            set gtkEntrySelectOnFocus(val: boolean);
            /**
             * When %TRUE, keyboard navigation and other input-related errors
             * will cause a beep.
             *
             * Since the error bell is implemented using gdk_surface_beep(), the
             * windowing system may offer ways to configure the error bell in many
             * ways, such as flashing the window or similar visual effects.
             */
            get gtk_error_bell(): boolean;
            set gtk_error_bell(val: boolean);
            /**
             * When %TRUE, keyboard navigation and other input-related errors
             * will cause a beep.
             *
             * Since the error bell is implemented using gdk_surface_beep(), the
             * windowing system may offer ways to configure the error bell in many
             * ways, such as flashing the window or similar visual effects.
             */
            get gtkErrorBell(): boolean;
            set gtkErrorBell(val: boolean);
            /**
             * The default font to use.
             *
             * GTK uses the family name and size from this string.
             */
            get gtk_font_name(): string;
            set gtk_font_name(val: string);
            /**
             * The default font to use.
             *
             * GTK uses the family name and size from this string.
             */
            get gtkFontName(): string;
            set gtkFontName(val: string);
            /**
             * How GTK font rendering is set up.
             *
             * When set to [enum`Gtk`.FontRendering.MANUAL], GTK respects the low-level
             * font-related settings ([property`Gtk`.Settings:gtk-hint-font-metrics],
             * [property`Gtk`.Settings:gtk-xft-antialias], [property`Gtk`.Settings:gtk-xft-hinting],
             * [property`Gtk`.Settings:gtk-xft-hintstyle] and [property`Gtk`.Settings:gtk-xft-rgba])
             * as much as practical.
             *
             * When set to [enum`Gtk`.FontRendering.AUTOMATIC], GTK will consider factors such
             * as screen resolution and scale in deciding how to render fonts.
             */
            get gtk_font_rendering(): FontRendering;
            set gtk_font_rendering(val: FontRendering);
            /**
             * How GTK font rendering is set up.
             *
             * When set to [enum`Gtk`.FontRendering.MANUAL], GTK respects the low-level
             * font-related settings ([property`Gtk`.Settings:gtk-hint-font-metrics],
             * [property`Gtk`.Settings:gtk-xft-antialias], [property`Gtk`.Settings:gtk-xft-hinting],
             * [property`Gtk`.Settings:gtk-xft-hintstyle] and [property`Gtk`.Settings:gtk-xft-rgba])
             * as much as practical.
             *
             * When set to [enum`Gtk`.FontRendering.AUTOMATIC], GTK will consider factors such
             * as screen resolution and scale in deciding how to render fonts.
             */
            get gtkFontRendering(): FontRendering;
            set gtkFontRendering(val: FontRendering);
            /**
             * Timestamp of the current fontconfig configuration.
             */
            get gtk_fontconfig_timestamp(): number;
            set gtk_fontconfig_timestamp(val: number);
            /**
             * Timestamp of the current fontconfig configuration.
             */
            get gtkFontconfigTimestamp(): number;
            set gtkFontconfigTimestamp(val: number);
            /**
             * Whether hinting should be applied to font metrics.
             *
             * Note that this also turns off subpixel positioning of glyphs,
             * since it conflicts with metrics hinting.
             */
            get gtk_hint_font_metrics(): boolean;
            set gtk_hint_font_metrics(val: boolean);
            /**
             * Whether hinting should be applied to font metrics.
             *
             * Note that this also turns off subpixel positioning of glyphs,
             * since it conflicts with metrics hinting.
             */
            get gtkHintFontMetrics(): boolean;
            set gtkHintFontMetrics(val: boolean);
            /**
             * Name of the icon theme to use.
             *
             * See [class`Gtk`.IconTheme] for details about how
             * GTK handles icon themes.
             */
            get gtk_icon_theme_name(): string;
            set gtk_icon_theme_name(val: string);
            /**
             * Name of the icon theme to use.
             *
             * See [class`Gtk`.IconTheme] for details about how
             * GTK handles icon themes.
             */
            get gtkIconThemeName(): string;
            set gtkIconThemeName(val: string);
            /**
             * Which IM (input method) module should be used by default.
             *
             * This is the input method that will be used if the user has not
             * explicitly chosen another input method from the IM context menu.
             * This also can be a colon-separated list of input methods, which GTK
             * will try in turn until it finds one available on the system.
             *
             * See [class`Gtk`.IMContext].
             */
            get gtk_im_module(): string;
            set gtk_im_module(val: string);
            /**
             * Which IM (input method) module should be used by default.
             *
             * This is the input method that will be used if the user has not
             * explicitly chosen another input method from the IM context menu.
             * This also can be a colon-separated list of input methods, which GTK
             * will try in turn until it finds one available on the system.
             *
             * See [class`Gtk`.IMContext].
             */
            get gtkImModule(): string;
            set gtkImModule(val: string);
            /**
             * Whether GTK should make sure that text can be navigated with
             * a caret, even if it is not editable.
             *
             * This is useful when using a screen reader.
             */
            get gtk_keynav_use_caret(): boolean;
            set gtk_keynav_use_caret(val: boolean);
            /**
             * Whether GTK should make sure that text can be navigated with
             * a caret, even if it is not editable.
             *
             * This is useful when using a screen reader.
             */
            get gtkKeynavUseCaret(): boolean;
            set gtkKeynavUseCaret(val: boolean);
            /**
             * Whether to select the contents of a selectable
             * label when it is focused.
             */
            get gtk_label_select_on_focus(): boolean;
            set gtk_label_select_on_focus(val: boolean);
            /**
             * Whether to select the contents of a selectable
             * label when it is focused.
             */
            get gtkLabelSelectOnFocus(): boolean;
            set gtkLabelSelectOnFocus(val: boolean);
            /**
             * The time for a button or touch press to be considered a “long press”.
             *
             * See [class`Gtk`.GestureLongPress].
             */
            get gtk_long_press_time(): number;
            set gtk_long_press_time(val: number);
            /**
             * The time for a button or touch press to be considered a “long press”.
             *
             * See [class`Gtk`.GestureLongPress].
             */
            get gtkLongPressTime(): number;
            set gtkLongPressTime(val: number);
            /**
             * Whether scrolled windows may use overlaid scrolling indicators.
             *
             * If this is set to %FALSE, scrolled windows will have permanent
             * scrollbars.
             */
            get gtk_overlay_scrolling(): boolean;
            set gtk_overlay_scrolling(val: boolean);
            /**
             * Whether scrolled windows may use overlaid scrolling indicators.
             *
             * If this is set to %FALSE, scrolled windows will have permanent
             * scrollbars.
             */
            get gtkOverlayScrolling(): boolean;
            set gtkOverlayScrolling(val: boolean);
            /**
             * If the value of this setting is %TRUE, clicking the primary button in a
             * `GtkRange` trough will move the slider, and hence set the range’s value, to
             * the point that you clicked.
             *
             * If it is %FALSE, a primary click will cause the slider/value to move
             * by the range’s page-size towards the point clicked.
             *
             * Whichever action you choose for the primary button, the other action will
             * be available by holding Shift and primary-clicking, or clicking the middle
             * mouse button.
             */
            get gtk_primary_button_warps_slider(): boolean;
            set gtk_primary_button_warps_slider(val: boolean);
            /**
             * If the value of this setting is %TRUE, clicking the primary button in a
             * `GtkRange` trough will move the slider, and hence set the range’s value, to
             * the point that you clicked.
             *
             * If it is %FALSE, a primary click will cause the slider/value to move
             * by the range’s page-size towards the point clicked.
             *
             * Whichever action you choose for the primary button, the other action will
             * be available by holding Shift and primary-clicking, or clicking the middle
             * mouse button.
             */
            get gtkPrimaryButtonWarpsSlider(): boolean;
            set gtkPrimaryButtonWarpsSlider(val: boolean);
            /**
             * A comma-separated list of print backends to use in the print
             * dialog.
             *
             * Available print backends depend on the GTK installation,
             * and may include "file", "cups", "lpr" or "papi".
             */
            get gtk_print_backends(): string;
            set gtk_print_backends(val: string);
            /**
             * A comma-separated list of print backends to use in the print
             * dialog.
             *
             * Available print backends depend on the GTK installation,
             * and may include "file", "cups", "lpr" or "papi".
             */
            get gtkPrintBackends(): string;
            set gtkPrintBackends(val: string);
            /**
             * A command to run for displaying the print preview.
             *
             * The command should contain a `%f` placeholder, which will get
             * replaced by the path to the pdf file. The command may also
             * contain a `%s` placeholder, which will get replaced by the
             * path to a file containing the print settings in the format
             * produced by [method`Gtk`.PrintSettings.to_file].
             *
             * The preview application is responsible for removing the pdf
             * file and the print settings file when it is done.
             */
            get gtk_print_preview_command(): string;
            set gtk_print_preview_command(val: string);
            /**
             * A command to run for displaying the print preview.
             *
             * The command should contain a `%f` placeholder, which will get
             * replaced by the path to the pdf file. The command may also
             * contain a `%s` placeholder, which will get replaced by the
             * path to a file containing the print settings in the format
             * produced by [method`Gtk`.PrintSettings.to_file].
             *
             * The preview application is responsible for removing the pdf
             * file and the print settings file when it is done.
             */
            get gtkPrintPreviewCommand(): string;
            set gtkPrintPreviewCommand(val: string);
            /**
             * Whether GTK should keep track of items inside the recently used
             * resources list.
             *
             * If set to %FALSE, the list will always be empty.
             */
            get gtk_recent_files_enabled(): boolean;
            set gtk_recent_files_enabled(val: boolean);
            /**
             * Whether GTK should keep track of items inside the recently used
             * resources list.
             *
             * If set to %FALSE, the list will always be empty.
             */
            get gtkRecentFilesEnabled(): boolean;
            set gtkRecentFilesEnabled(val: boolean);
            /**
             * The maximum age, in days, of the items inside the recently used
             * resources list.
             *
             * Items older than this setting will be excised from the list.
             * If set to 0, the list will always be empty; if set to -1, no
             * item will be removed.
             */
            get gtk_recent_files_max_age(): number;
            set gtk_recent_files_max_age(val: number);
            /**
             * The maximum age, in days, of the items inside the recently used
             * resources list.
             *
             * Items older than this setting will be excised from the list.
             * If set to 0, the list will always be empty; if set to -1, no
             * item will be removed.
             */
            get gtkRecentFilesMaxAge(): number;
            set gtkRecentFilesMaxAge(val: number);
            /**
             * Set to %TRUE if the desktop environment is displaying
             * the app menu, %FALSE if the app should display it itself.
             */
            get gtk_shell_shows_app_menu(): boolean;
            set gtk_shell_shows_app_menu(val: boolean);
            /**
             * Set to %TRUE if the desktop environment is displaying
             * the app menu, %FALSE if the app should display it itself.
             */
            get gtkShellShowsAppMenu(): boolean;
            set gtkShellShowsAppMenu(val: boolean);
            /**
             * Set to %TRUE if the desktop environment is displaying
             * the desktop folder, %FALSE if not.
             */
            get gtk_shell_shows_desktop(): boolean;
            set gtk_shell_shows_desktop(val: boolean);
            /**
             * Set to %TRUE if the desktop environment is displaying
             * the desktop folder, %FALSE if not.
             */
            get gtkShellShowsDesktop(): boolean;
            set gtkShellShowsDesktop(val: boolean);
            /**
             * Set to %TRUE if the desktop environment is displaying
             * the menubar, %FALSE if the app should display it itself.
             */
            get gtk_shell_shows_menubar(): boolean;
            set gtk_shell_shows_menubar(val: boolean);
            /**
             * Set to %TRUE if the desktop environment is displaying
             * the menubar, %FALSE if the app should display it itself.
             */
            get gtkShellShowsMenubar(): boolean;
            set gtkShellShowsMenubar(val: boolean);
            /**
             * When %TRUE, widgets like switches include shapes to indicate their on/off state.
             */
            get gtk_show_status_shapes(): boolean;
            set gtk_show_status_shapes(val: boolean);
            /**
             * When %TRUE, widgets like switches include shapes to indicate their on/off state.
             */
            get gtkShowStatusShapes(): boolean;
            set gtkShowStatusShapes(val: boolean);
            /**
             * The XDG sound theme to use for event sounds.
             *
             * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
             * for more information on event sounds and sound themes.
             *
             * GTK itself does not support event sounds, you have to use
             * a loadable module like the one that comes with libcanberra.
             */
            get gtk_sound_theme_name(): string;
            set gtk_sound_theme_name(val: string);
            /**
             * The XDG sound theme to use for event sounds.
             *
             * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
             * for more information on event sounds and sound themes.
             *
             * GTK itself does not support event sounds, you have to use
             * a loadable module like the one that comes with libcanberra.
             */
            get gtkSoundThemeName(): string;
            set gtkSoundThemeName(val: string);
            /**
             * Whether two cursors should be displayed for mixed left-to-right and
             * right-to-left text.
             */
            get gtk_split_cursor(): boolean;
            set gtk_split_cursor(val: boolean);
            /**
             * Whether two cursors should be displayed for mixed left-to-right and
             * right-to-left text.
             */
            get gtkSplitCursor(): boolean;
            set gtkSplitCursor(val: boolean);
            /**
             * Name of the theme to load.
             *
             * See [class`Gtk`.CssProvider] for details about how
             * GTK finds the CSS stylesheet for a theme.
             */
            get gtk_theme_name(): string;
            set gtk_theme_name(val: string);
            /**
             * Name of the theme to load.
             *
             * See [class`Gtk`.CssProvider] for details about how
             * GTK finds the CSS stylesheet for a theme.
             */
            get gtkThemeName(): string;
            set gtkThemeName(val: string);
            /**
             * Determines the action to take when a double-click
             * occurs on the titlebar of client-side decorated windows.
             *
             * Recognized actions are minimize, toggle-maximize, menu, lower
             * or none.
             */
            get gtk_titlebar_double_click(): string;
            set gtk_titlebar_double_click(val: string);
            /**
             * Determines the action to take when a double-click
             * occurs on the titlebar of client-side decorated windows.
             *
             * Recognized actions are minimize, toggle-maximize, menu, lower
             * or none.
             */
            get gtkTitlebarDoubleClick(): string;
            set gtkTitlebarDoubleClick(val: string);
            /**
             * Determines the action to take when a middle-click
             * occurs on the titlebar of client-side decorated windows.
             *
             * Recognized actions are minimize, toggle-maximize, menu, lower
             * or none.
             */
            get gtk_titlebar_middle_click(): string;
            set gtk_titlebar_middle_click(val: string);
            /**
             * Determines the action to take when a middle-click
             * occurs on the titlebar of client-side decorated windows.
             *
             * Recognized actions are minimize, toggle-maximize, menu, lower
             * or none.
             */
            get gtkTitlebarMiddleClick(): string;
            set gtkTitlebarMiddleClick(val: string);
            /**
             * Determines the action to take when a right-click
             * occurs on the titlebar of client-side decorated windows.
             *
             * Recognized actions are minimize, toggle-maximize, menu, lower
             * or none.
             */
            get gtk_titlebar_right_click(): string;
            set gtk_titlebar_right_click(val: string);
            /**
             * Determines the action to take when a right-click
             * occurs on the titlebar of client-side decorated windows.
             *
             * Recognized actions are minimize, toggle-maximize, menu, lower
             * or none.
             */
            get gtkTitlebarRightClick(): string;
            set gtkTitlebarRightClick(val: string);
            /**
             * Whether to antialias fonts.
             *
             * The values are 0 for no, 1 for yes, or -1 for the system default.
             */
            get gtk_xft_antialias(): number;
            set gtk_xft_antialias(val: number);
            /**
             * Whether to antialias fonts.
             *
             * The values are 0 for no, 1 for yes, or -1 for the system default.
             */
            get gtkXftAntialias(): number;
            set gtkXftAntialias(val: number);
            /**
             * The font resolution, in 1024 * dots/inch.
             *
             * -1 to use the default value.
             */
            get gtk_xft_dpi(): number;
            set gtk_xft_dpi(val: number);
            /**
             * The font resolution, in 1024 * dots/inch.
             *
             * -1 to use the default value.
             */
            get gtkXftDpi(): number;
            set gtkXftDpi(val: number);
            /**
             * Whether to enable font hinting.
             *
             * The values are 0 for no, 1 for yes, or -1 for the system default.
             */
            get gtk_xft_hinting(): number;
            set gtk_xft_hinting(val: number);
            /**
             * Whether to enable font hinting.
             *
             * The values are 0 for no, 1 for yes, or -1 for the system default.
             */
            get gtkXftHinting(): number;
            set gtkXftHinting(val: number);
            /**
             * What degree of font hinting to use.
             *
             * The possible vaues are hintnone, hintslight,
             * hintmedium, hintfull.
             */
            get gtk_xft_hintstyle(): string;
            set gtk_xft_hintstyle(val: string);
            /**
             * What degree of font hinting to use.
             *
             * The possible vaues are hintnone, hintslight,
             * hintmedium, hintfull.
             */
            get gtkXftHintstyle(): string;
            set gtkXftHintstyle(val: string);
            /**
             * The type of subpixel antialiasing to use.
             *
             * The possible values are none, rgb, bgr, vrgb, vbgr.
             *
             * Note that GSK does not support subpixel antialiasing, and this
             * setting has no effect on font rendering in GTK.
             */
            get gtk_xft_rgba(): string;
            set gtk_xft_rgba(val: string);
            /**
             * The type of subpixel antialiasing to use.
             *
             * The possible values are none, rgb, bgr, vrgb, vbgr.
             *
             * Note that GSK does not support subpixel antialiasing, and this
             * setting has no effect on font rendering in GTK.
             */
            get gtkXftRgba(): string;
            set gtkXftRgba(val: string);

            // Constructors

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

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

            // Static methods

            /**
             * Gets the `GtkSettings` object for the default display, creating
             * it if necessary.
             *
             * See [func`Gtk`.Settings.get_for_display].
             */
            static get_default(): Settings | null;
            /**
             * Gets the `GtkSettings` object for `display,` creating it if necessary.
             * @param display a `GdkDisplay`
             */
            static get_for_display(display: Gdk.Display): Settings;

            // Methods

            /**
             * Undoes the effect of calling g_object_set() to install an
             * application-specific value for a setting.
             *
             * After this call, the setting will again follow the session-wide
             * value for this setting.
             * @param name the name of the setting to reset
             */
            reset_property(name: string): void;

            // Inherited methods
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Shortcut {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                action: ShortcutAction;
                arguments: GLib.Variant;
                trigger: ShortcutTrigger;
            }
        }

        /**
         * A `GtkShortcut` describes a keyboard shortcut.
         *
         * It contains a description of how to trigger the shortcut via a
         * [class`Gtk`.ShortcutTrigger] and a way to activate the shortcut
         * on a widget via a [class`Gtk`.ShortcutAction].
         *
         * The actual work is usually done via [class`Gtk`.ShortcutController],
         * which decides if and when to activate a shortcut. Using that controller
         * directly however is rarely necessary as various higher level
         * convenience APIs exist on `GtkWidget`s that make it easier to use
         * shortcuts in GTK.
         *
         * `GtkShortcut` does provide functionality to make it easy for users
         * to work with shortcuts, either by providing informational strings
         * for display purposes or by allowing shortcuts to be configured.
         */
        class Shortcut extends GObject.Object {
            static $gtype: GObject.GType<Shortcut>;

            // Properties

            /**
             * The action that gets activated by this shortcut.
             */
            get action(): ShortcutAction;
            set action(val: ShortcutAction);
            /**
             * Arguments passed to activation.
             */
            get arguments(): GLib.Variant;
            set arguments(val: GLib.Variant);
            /**
             * The trigger that triggers this shortcut.
             */
            get trigger(): ShortcutTrigger;
            set trigger(val: ShortcutTrigger);

            // Constructors

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

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

            static ['new'](trigger?: ShortcutTrigger | null, action?: ShortcutAction | null): Shortcut;

            // Methods

            /**
             * Gets the action that is activated by this shortcut.
             * @returns the action
             */
            get_action(): ShortcutAction | null;
            /**
             * Gets the arguments that are passed when activating the shortcut.
             * @returns the arguments
             */
            get_arguments(): GLib.Variant | null;
            /**
             * Gets the trigger used to trigger `self`.
             * @returns the trigger used
             */
            get_trigger(): ShortcutTrigger | null;
            /**
             * Sets the new action for `self` to be `action`.
             * @param action The new action.   If the @action is %NULL, the nothing action will be used.
             */
            set_action(action?: ShortcutAction | null): void;
            /**
             * Sets the arguments to pass when activating the shortcut.
             * @param args arguments to pass when activating @self
             */
            set_arguments(args?: GLib.Variant | null): void;
            /**
             * Sets the new trigger for `self` to be `trigger`.
             * @param trigger The new trigger.   If the @trigger is %NULL, the never trigger will be used.
             */
            set_trigger(trigger?: ShortcutTrigger | null): void;
        }

        namespace ShortcutAction {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * `GtkShortcutAction` encodes an action that can be triggered by a
         * keyboard shortcut.
         *
         * `GtkShortcutActions` contain functions that allow easy presentation
         * to end users as well as being printed for debugging.
         *
         * All `GtkShortcutActions` are immutable, you can only specify their
         * properties during construction. If you want to change a action, you
         * have to replace it with a new one. If you need to pass arguments to
         * an action, these are specified by the higher-level `GtkShortcut` object.
         *
         * To activate a `GtkShortcutAction` manually, [method`Gtk`.ShortcutAction.activate]
         * can be called.
         *
         * GTK provides various actions:
         *
         *  - [class`Gtk`.MnemonicAction]: a shortcut action that calls
         *    gtk_widget_mnemonic_activate()
         *  - [class`Gtk`.CallbackAction]: a shortcut action that invokes
         *    a given callback
         *  - [class`Gtk`.SignalAction]: a shortcut action that emits a
         *    given signal
         *  - [class`Gtk`.ActivateAction]: a shortcut action that calls
         *    gtk_widget_activate()
         *  - [class`Gtk`.NamedAction]: a shortcut action that calls
         *    gtk_widget_activate_action()
         *  - [class`Gtk`.NothingAction]: a shortcut action that does nothing
         */
        abstract class ShortcutAction extends GObject.Object {
            static $gtype: GObject.GType<ShortcutAction>;

            // Constructors

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

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

            static parse_string(string: string): ShortcutAction;

            // Methods

            /**
             * Activates the action on the `widget` with the given `args`.
             *
             * Note that some actions ignore the passed in `flags,` `widget` or `args`.
             *
             * Activation of an action can fail for various reasons. If the action
             * is not supported by the `widget,` if the `args` don't match the action
             * or if the activation otherwise had no effect, %FALSE will be returned.
             * @param flags flags to activate with
             * @param widget Target of the activation
             * @param args arguments to pass
             * @returns %TRUE if this action was activated successfully
             */
            activate(flags: ShortcutActionFlags | null, widget: Widget, args?: GLib.Variant | null): boolean;
            /**
             * Prints the given action into a string for the developer.
             *
             * This is meant for debugging and logging.
             *
             * The form of the representation may change at any time and is
             * not guaranteed to stay identical.
             * @param string a `GString` to print into
             */
            print(string: GLib.String): void;
            /**
             * Prints the given action into a human-readable string.
             *
             * This is a small wrapper around [method`Gtk`.ShortcutAction.print]
             * to help when debugging.
             * @returns a new string
             */
            to_string(): string;
        }

        namespace ShortcutController {
            // Constructor properties interface

            interface ConstructorProps<A extends GObject.Object = GObject.Object>
                extends EventController.ConstructorProps,
                    Gio.ListModel.ConstructorProps,
                    Buildable.ConstructorProps {
                item_type: GObject.GType;
                itemType: GObject.GType;
                mnemonic_modifiers: Gdk.ModifierType;
                mnemonicModifiers: Gdk.ModifierType;
                model: Gio.ListModel;
                n_items: number;
                nItems: number;
                scope: ShortcutScope;
            }
        }

        /**
         * `GtkShortcutController` is an event controller that manages shortcuts.
         *
         * Most common shortcuts are using this controller implicitly, e.g. by
         * adding a mnemonic underline to a [class`Gtk`.Label], or by installing a key
         * binding using [method`Gtk`.WidgetClass.add_binding], or by adding accelerators
         * to global actions using [method`Gtk`.Application.set_accels_for_action].
         *
         * But it is possible to create your own shortcut controller, and add
         * shortcuts to it.
         *
         * `GtkShortcutController` implements [iface`Gio`.ListModel] for querying the
         * shortcuts that have been added to it.
         *
         * # GtkShortcutController as GtkBuildable
         *
         * `GtkShortcutController`s can be created in [class`Gtk`.Builder] ui files, to set up
         * shortcuts in the same place as the widgets.
         *
         * An example of a UI definition fragment with `GtkShortcutController`:
         * ```xml
         *   <object class='GtkButton'>
         *     <child>
         *       <object class='GtkShortcutController'>
         *         <property name='scope'>managed</property>
         *         <child>
         *           <object class='GtkShortcut'>
         *             <property name='trigger'>&lt;Control&gt;k</property>
         *             <property name='action'>activate</property>
         *           </object>
         *         </child>
         *       </object>
         *     </child>
         *   </object>
         * ```
         *
         * This example creates a [class`Gtk`.ActivateAction] for triggering the
         * `activate` signal of the [class`Gtk`.Button]. See [ctor`Gtk`.ShortcutAction.parse_string]
         * for the syntax for other kinds of [class`Gtk`.ShortcutAction]. See
         * [ctor`Gtk`.ShortcutTrigger.parse_string] to learn more about the syntax
         * for triggers.
         */
        class ShortcutController<A extends GObject.Object = GObject.Object>
            extends EventController
            implements Gio.ListModel<A>, Buildable
        {
            static $gtype: GObject.GType<ShortcutController>;

            // Properties

            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get item_type(): GObject.GType;
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get itemType(): GObject.GType;
            /**
             * The modifiers that need to be pressed to allow mnemonics activation.
             */
            get mnemonic_modifiers(): Gdk.ModifierType;
            set mnemonic_modifiers(val: Gdk.ModifierType);
            /**
             * The modifiers that need to be pressed to allow mnemonics activation.
             */
            get mnemonicModifiers(): Gdk.ModifierType;
            set mnemonicModifiers(val: Gdk.ModifierType);
            /**
             * A list model to take shortcuts from.
             */
            set model(val: Gio.ListModel);
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get n_items(): number;
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get nItems(): number;
            /**
             * What scope the shortcuts will be handled in.
             */
            get scope(): ShortcutScope;
            set scope(val: ShortcutScope);

            // Constructors

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

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

            static ['new'](): ShortcutController;

            static new_for_model(model: Gio.ListModel): ShortcutController;

            // Methods

            /**
             * Adds `shortcut` to the list of shortcuts handled by `self`.
             *
             * If this controller uses an external shortcut list, this
             * function does nothing.
             * @param shortcut a `GtkShortcut`
             */
            add_shortcut(shortcut: Shortcut): void;
            /**
             * Gets the mnemonics modifiers for when this controller activates its shortcuts.
             * @returns the controller's mnemonics modifiers
             */
            get_mnemonics_modifiers(): Gdk.ModifierType;
            /**
             * Gets the scope for when this controller activates its shortcuts.
             *
             * See [method`Gtk`.ShortcutController.set_scope] for details.
             * @returns the controller's scope
             */
            get_scope(): ShortcutScope;
            /**
             * Removes `shortcut` from the list of shortcuts handled by `self`.
             *
             * If `shortcut` had not been added to `controller` or this controller
             * uses an external shortcut list, this function does nothing.
             * @param shortcut a `GtkShortcut`
             */
            remove_shortcut(shortcut: Shortcut): void;
            /**
             * Sets the controller to use the given modifier for mnemonics.
             *
             * The mnemonics modifiers determines which modifiers need to be pressed to allow
             * activation of shortcuts with mnemonics triggers.
             *
             * GTK normally uses the Alt modifier for mnemonics, except in `GtkPopoverMenu`s,
             * where mnemonics can be triggered without any modifiers. It should be very
             * rarely necessary to change this, and doing so is likely to interfere with
             * other shortcuts.
             *
             * This value is only relevant for local shortcut controllers. Global and managed
             * shortcut controllers will have their shortcuts activated from other places which
             * have their own modifiers for activating mnemonics.
             * @param modifiers the new mnemonics_modifiers to use
             */
            set_mnemonics_modifiers(modifiers: Gdk.ModifierType | null): void;
            /**
             * Sets the controller to have the given `scope`.
             *
             * The scope allows shortcuts to be activated outside of the normal
             * event propagation. In particular, it allows installing global
             * keyboard shortcuts that can be activated even when a widget does
             * not have focus.
             *
             * With %GTK_SHORTCUT_SCOPE_LOCAL, shortcuts will only be activated
             * when the widget has focus.
             * @param scope the new scope to use
             */
            set_scope(scope: ShortcutScope | null): void;

            // Inherited methods
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             * @returns the #GType of the items contained in @list.
             */
            get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             * @returns the number of items in @list.
             */
            get_n_items(): number;
            /**
             * Get the item at `position`.
             *
             * If `position` is greater than the number of items in `list,` %NULL is
             * returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.
             *
             * This function is meant to be used by language bindings in place
             * of g_list_model_get_item().
             *
             * See also: g_list_model_get_n_items()
             * @param position the position of the item to fetch
             * @returns the object at @position.
             */
            get_item(position: number): A | null;
            /**
             * Emits the #GListModel::items-changed signal on `list`.
             *
             * This function should only be called by classes implementing
             * #GListModel. It has to be called after the internal representation
             * of `list` has been updated, because handlers connected to this signal
             * might query the new state of the list.
             *
             * Implementations must only make changes to the model (as visible to
             * its consumer) in places that will not cause problems for that
             * consumer.  For models that are driven directly by a write API (such
             * as #GListStore), changes can be reported in response to uses of that
             * API.  For models that represent remote data, changes should only be
             * made from a fresh mainloop dispatch.  It is particularly not
             * permitted to make changes in response to a call to the #GListModel
             * consumer API.
             *
             * Stated another way: in general, it is assumed that code making a
             * series of accesses to the model via the API, without returning to the
             * mainloop, and without calling other code, will continue to view the
             * same contents of the model.
             * @param position the position at which @list changed
             * @param removed the number of items removed
             * @param added the number of items added
             */
            items_changed(position: number, removed: number, added: number): void;
            /**
             * Get the item at `position`. If `position` is greater than the number of
             * items in `list,` %NULL is returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.  See g_list_model_get_n_items().
             *
             * The same #GObject instance may not appear more than once in a #GListModel.
             * @param position the position of the item to fetch
             */
            vfunc_get_item(position: number): A | null;
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             */
            vfunc_get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             */
            vfunc_get_n_items(): number;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ShortcutLabel {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                accelerator: string;
                disabled_text: string;
                disabledText: string;
            }
        }

        /**
         * `GtkShortcutLabel` displays a single keyboard shortcut or gesture.
         *
         * The main use case for `GtkShortcutLabel` is inside a [class`Gtk`.ShortcutsWindow].
         */
        class ShortcutLabel extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<ShortcutLabel>;

            // Properties

            /**
             * The accelerator that `self` displays.
             *
             * See [property`Gtk`.ShortcutsShortcut:accelerator]
             * for the accepted syntax.
             */
            get accelerator(): string;
            set accelerator(val: string);
            /**
             * The text that is displayed when no accelerator is set.
             */
            get disabled_text(): string;
            set disabled_text(val: string);
            /**
             * The text that is displayed when no accelerator is set.
             */
            get disabledText(): string;
            set disabledText(val: string);

            // Constructors

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

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

            static ['new'](accelerator: string): ShortcutLabel;

            // Methods

            /**
             * Retrieves the current accelerator of `self`.
             * @returns the current accelerator.
             */
            get_accelerator(): string | null;
            /**
             * Retrieves the text that is displayed when no accelerator is set.
             * @returns the current text displayed when no accelerator is set.
             */
            get_disabled_text(): string | null;
            /**
             * Sets the accelerator to be displayed by `self`.
             * @param accelerator the new accelerator
             */
            set_accelerator(accelerator: string): void;
            /**
             * Sets the text to be displayed by `self` when no accelerator is set.
             * @param disabled_text the text to be displayed when no accelerator is set
             */
            set_disabled_text(disabled_text: string): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ShortcutTrigger {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * `GtkShortcutTrigger` tracks how a `GtkShortcut` should be activated.
         *
         * To find out if a `GtkShortcutTrigger` triggers, you can call
         * [method`Gtk`.ShortcutTrigger.trigger] on a `GdkEvent`.
         *
         * `GtkShortcutTriggers` contain functions that allow easy presentation
         * to end users as well as being printed for debugging.
         *
         * All `GtkShortcutTriggers` are immutable, you can only specify their
         * properties during construction. If you want to change a trigger, you
         * have to replace it with a new one.
         */
        abstract class ShortcutTrigger extends GObject.Object {
            static $gtype: GObject.GType<ShortcutTrigger>;

            // Constructors

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

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

            static parse_string(string: string): ShortcutTrigger;

            // Methods

            /**
             * The types of `trigger1` and `trigger2` are `gconstpointer` only to allow
             * use of this function as a `GCompareFunc`.
             *
             * They must each be a `GtkShortcutTrigger`.
             * @param trigger2 a `GtkShortcutTrigger`
             * @returns An integer less than, equal to, or greater than zero if   @trigger1 is found, respectively, to be less than, to match,   or be greater than @trigger2.
             */
            compare(trigger2: ShortcutTrigger): number;
            /**
             * Checks if `trigger1` and `trigger2` trigger under the same conditions.
             *
             * The types of `one` and `two` are `gconstpointer` only to allow use of this
             * function with `GHashTable`. They must each be a `GtkShortcutTrigger`.
             * @param trigger2 a `GtkShortcutTrigger`
             * @returns %TRUE if @trigger1 and @trigger2 are equal
             */
            equal(trigger2: ShortcutTrigger): boolean;
            /**
             * Generates a hash value for a `GtkShortcutTrigger`.
             *
             * The output of this function is guaranteed to be the same for a given
             * value only per-process. It may change between different processor
             * architectures or even different versions of GTK. Do not use this
             * function as a basis for building protocols or file formats.
             *
             * The types of `trigger` is `gconstpointer` only to allow use of this
             * function with `GHashTable`. They must each be a `GtkShortcutTrigger`.
             * @returns a hash value corresponding to @trigger
             */
            hash(): number;
            /**
             * Prints the given trigger into a string for the developer.
             * This is meant for debugging and logging.
             *
             * The form of the representation may change at any time
             * and is not guaranteed to stay identical.
             * @param string a `GString` to print into
             */
            print(string: GLib.String): void;
            /**
             * Prints the given trigger into a string.
             *
             * This function is returning a translated string for presentation
             * to end users for example in menu items or in help texts.
             *
             * The `display` in use may influence the resulting string in
             * various forms, such as resolving hardware keycodes or by
             * causing display-specific modifier names.
             *
             * The form of the representation may change at any time and is
             * not guaranteed to stay identical.
             * @param display `GdkDisplay` to print for
             * @param string a `GString` to print into
             * @returns %TRUE if something was printed or %FALSE if the   trigger did not have a textual representation suitable   for end users.
             */
            print_label(display: Gdk.Display, string: GLib.String): boolean;
            /**
             * Gets textual representation for the given trigger.
             *
             * This function is returning a translated string for
             * presentation to end users for example in menu items
             * or in help texts.
             *
             * The `display` in use may influence the resulting string in
             * various forms, such as resolving hardware keycodes or by
             * causing display-specific modifier names.
             *
             * The form of the representation may change at any time and is
             * not guaranteed to stay identical.
             * @param display `GdkDisplay` to print for
             * @returns a new string
             */
            to_label(display: Gdk.Display): string;
            /**
             * Prints the given trigger into a human-readable string.
             *
             * This is a small wrapper around [method`Gtk`.ShortcutTrigger.print]
             * to help when debugging.
             * @returns a new string
             */
            to_string(): string;
            /**
             * Checks if the given `event` triggers `self`.
             * @param event the event to check
             * @param enable_mnemonics %TRUE if mnemonics should trigger. Usually the   value of this property is determined by checking that the passed   in @event is a Key event and has the right modifiers set.
             * @returns Whether the event triggered the shortcut
             */
            trigger(event: Gdk.Event, enable_mnemonics: boolean): Gdk.KeyMatch;
        }

        namespace ShortcutsGroup {
            // Constructor properties interface

            interface ConstructorProps
                extends Box.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Orientable.ConstructorProps {
                accel_size_group: SizeGroup;
                accelSizeGroup: SizeGroup;
                height: number;
                title: string;
                title_size_group: SizeGroup;
                titleSizeGroup: SizeGroup;
                view: string;
            }
        }

        /**
         * A `GtkShortcutsGroup` represents a group of related keyboard shortcuts
         * or gestures.
         *
         * The group has a title. It may optionally be associated with a view
         * of the application, which can be used to show only relevant shortcuts
         * depending on the application context.
         *
         * This widget is only meant to be used with [class`Gtk`.ShortcutsWindow].
         *
         * The recommended way to construct a `GtkShortcutsGroup` is with
         * [class`Gtk`.Builder], by using the `<child>` tag to populate a
         * `GtkShortcutsGroup` with one or more [class`Gtk`.ShortcutsShortcut]
         * instances.
         *
         * If you need to add a shortcut programmatically, use
         * [method`Gtk`.ShortcutsGroup.add_shortcut].
         */
        class ShortcutsGroup extends Box implements Accessible, Buildable, ConstraintTarget, Orientable {
            static $gtype: GObject.GType<ShortcutsGroup>;

            // Properties

            /**
             * The size group for the accelerator portion of shortcuts in this group.
             *
             * This is used internally by GTK, and must not be modified by applications.
             */
            set accel_size_group(val: SizeGroup);
            /**
             * The size group for the accelerator portion of shortcuts in this group.
             *
             * This is used internally by GTK, and must not be modified by applications.
             */
            set accelSizeGroup(val: SizeGroup);
            /**
             * A rough measure for the number of lines in this group.
             *
             * This is used internally by GTK, and is not useful for applications.
             */
            get height(): number;
            /**
             * The title for this group of shortcuts.
             */
            get title(): string;
            set title(val: string);
            /**
             * The size group for the textual portion of shortcuts in this group.
             *
             * This is used internally by GTK, and must not be modified by applications.
             */
            set title_size_group(val: SizeGroup);
            /**
             * The size group for the textual portion of shortcuts in this group.
             *
             * This is used internally by GTK, and must not be modified by applications.
             */
            set titleSizeGroup(val: SizeGroup);
            /**
             * An optional view that the shortcuts in this group are relevant for.
             *
             * The group will be hidden if the [property`Gtk`.ShortcutsWindow:view-name]
             * property does not match the view of this group.
             *
             * Set this to %NULL to make the group always visible.
             */
            get view(): string;
            set view(val: string);

            // Constructors

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

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

            // Methods

            /**
             * Adds a shortcut to the shortcuts group.
             *
             * This is the programmatic equivalent to using [class`Gtk`.Builder] and a
             * `<child>` tag to add the child. Adding children with other API is not
             * appropriate as `GtkShortcutsGroup` manages its children internally.
             * @param shortcut the `GtkShortcutsShortcut` to add
             */
            add_shortcut(shortcut: ShortcutsShortcut): void;

            // Inherited properties
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Inherited methods
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ShortcutsSection {
            // Signal callback interfaces

            interface ChangeCurrentPage {
                (offset: number): boolean;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Box.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Orientable.ConstructorProps {
                max_height: number;
                maxHeight: number;
                section_name: string;
                sectionName: string;
                title: string;
                view_name: string;
                viewName: string;
            }
        }

        /**
         * A `GtkShortcutsSection` collects all the keyboard shortcuts and gestures
         * for a major application mode.
         *
         * If your application needs multiple sections, you should give each
         * section a unique [property`Gtk`.ShortcutsSection:section-name] and
         * a [property`Gtk`.ShortcutsSection:title] that can be shown in the
         * section selector of the [class`Gtk`.ShortcutsWindow].
         *
         * The [property`Gtk`.ShortcutsSection:max-height] property can be used
         * to influence how the groups in the section are distributed over pages
         * and columns.
         *
         * This widget is only meant to be used with [class`Gtk`.ShortcutsWindow].
         *
         * The recommended way to construct a `GtkShortcutsSection` is with
         * [class`Gtk`.Builder], by using the `<child>` tag to populate a
         * `GtkShortcutsSection` with one or more [class`Gtk`.ShortcutsGroup]
         * instances, which in turn contain one or more [class`Gtk`.ShortcutsShortcut]
         * objects.
         *
         * If you need to add a group programmatically, use
         * [method`Gtk`.ShortcutsSection.add_group].
         *
         * # Shortcuts and Gestures
         *
         * Pan gestures allow to navigate between sections.
         *
         * The following signals have default keybindings:
         *
         * - [signal`Gtk`.ShortcutsSection::change-current-page]
         */
        class ShortcutsSection extends Box implements Accessible, Buildable, ConstraintTarget, Orientable {
            static $gtype: GObject.GType<ShortcutsSection>;

            // Properties

            /**
             * The maximum number of lines to allow per column.
             *
             * This property can be used to influence how the groups in this
             * section are distributed across pages and columns. The default
             * value of 15 should work in most cases.
             */
            get max_height(): number;
            set max_height(val: number);
            /**
             * The maximum number of lines to allow per column.
             *
             * This property can be used to influence how the groups in this
             * section are distributed across pages and columns. The default
             * value of 15 should work in most cases.
             */
            get maxHeight(): number;
            set maxHeight(val: number);
            /**
             * A unique name to identify this section among the sections
             * added to the `GtkShortcutsWindow`.
             *
             * Setting the [property`Gtk`.ShortcutsWindow:section-name] property
             * to this string will make this section shown in the `GtkShortcutsWindow`.
             */
            get section_name(): string;
            set section_name(val: string);
            /**
             * A unique name to identify this section among the sections
             * added to the `GtkShortcutsWindow`.
             *
             * Setting the [property`Gtk`.ShortcutsWindow:section-name] property
             * to this string will make this section shown in the `GtkShortcutsWindow`.
             */
            get sectionName(): string;
            set sectionName(val: string);
            /**
             * The string to show in the section selector of the `GtkShortcutsWindow`
             * for this section.
             *
             * If there is only one section, you don't need to set a title,
             * since the section selector will not be shown in this case.
             */
            get title(): string;
            set title(val: string);
            /**
             * A view name to filter the groups in this section by.
             *
             * See [property`Gtk`.ShortcutsGroup:view].
             *
             * Applications are expected to use the
             * [property`Gtk`.ShortcutsWindow:view-name] property
             * for this purpose.
             */
            get view_name(): string;
            set view_name(val: string);
            /**
             * A view name to filter the groups in this section by.
             *
             * See [property`Gtk`.ShortcutsGroup:view].
             *
             * Applications are expected to use the
             * [property`Gtk`.ShortcutsWindow:view-name] property
             * for this purpose.
             */
            get viewName(): string;
            set viewName(val: string);

            // Constructors

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

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

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'change-current-page', callback: (_source: this, offset: number) => boolean): number;
            connect_after(signal: 'change-current-page', callback: (_source: this, offset: number) => boolean): number;
            emit(signal: 'change-current-page', offset: number): void;

            // Methods

            /**
             * Adds a group to the shortcuts section.
             *
             * This is the programmatic equivalent to using [class`Gtk`.Builder] and a
             * `<child>` tag to add the child.
             *
             * Adding children with the `GtkBox` API is not appropriate, as
             * `GtkShortcutsSection` manages its children internally.
             * @param group the `GtkShortcutsGroup` to add
             */
            add_group(group: ShortcutsGroup): void;

            // Inherited properties
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Inherited methods
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ShortcutsShortcut {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                accel_size_group: SizeGroup;
                accelSizeGroup: SizeGroup;
                accelerator: string;
                action_name: string;
                actionName: string;
                direction: TextDirection;
                icon: Gio.Icon;
                icon_set: boolean;
                iconSet: boolean;
                shortcut_type: ShortcutType;
                shortcutType: ShortcutType;
                subtitle: string;
                subtitle_set: boolean;
                subtitleSet: boolean;
                title: string;
                title_size_group: SizeGroup;
                titleSizeGroup: SizeGroup;
            }
        }

        /**
         * A `GtkShortcutsShortcut` represents a single keyboard shortcut or gesture
         * with a short text.
         *
         * This widget is only meant to be used with `GtkShortcutsWindow`.
         */
        class ShortcutsShortcut extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<ShortcutsShortcut>;

            // Properties

            /**
             * The size group for the accelerator portion of this shortcut.
             *
             * This is used internally by GTK, and must not be modified by applications.
             */
            set accel_size_group(val: SizeGroup);
            /**
             * The size group for the accelerator portion of this shortcut.
             *
             * This is used internally by GTK, and must not be modified by applications.
             */
            set accelSizeGroup(val: SizeGroup);
            /**
             * The accelerator(s) represented by this object.
             *
             * This property is used if [property`Gtk`.ShortcutsShortcut:shortcut-type]
             * is set to %GTK_SHORTCUT_ACCELERATOR.
             *
             * The syntax of this property is (an extension of) the syntax understood
             * by [func`Gtk`.accelerator_parse]. Multiple accelerators can be specified
             * by separating them with a space, but keep in mind that the available width
             * is limited.
             *
             * It is also possible to specify ranges of shortcuts, using `...` between
             * the keys. Sequences of keys can be specified using a `+` or `&` between
             * the keys.
             *
             * Examples:
             *
             * - A single shortcut: `<ctl><alt>delete`
             * - Two alternative shortcuts: `<shift>a Home`
             * - A range of shortcuts: `<alt>1...<alt>9`
             * - Several keys pressed together: `Control_L&Control_R`
             * - A sequence of shortcuts or keys: `<ctl>c+<ctl>x`
             *
             * Use "+" instead of "&" when the keys may (or have to be) pressed
             * sequentially (e.g use "t+t" for 'press the t key twice').
             *
             * Note that `<`, `>` and `&` need to be escaped as `&lt;`, `&gt`; and `&amp`; when used
             * in .ui files.
             */
            get accelerator(): string;
            set accelerator(val: string);
            /**
             * A detailed action name.
             *
             * If this is set for a shortcut of type %GTK_SHORTCUT_ACCELERATOR,
             * then GTK will use the accelerators that are associated with the
             * action via [method`Gtk`.Application.set_accels_for_action], and
             * setting [property`Gtk`.ShortcutsShortcut:accelerator] is not necessary.
             */
            get action_name(): string;
            set action_name(val: string);
            /**
             * A detailed action name.
             *
             * If this is set for a shortcut of type %GTK_SHORTCUT_ACCELERATOR,
             * then GTK will use the accelerators that are associated with the
             * action via [method`Gtk`.Application.set_accels_for_action], and
             * setting [property`Gtk`.ShortcutsShortcut:accelerator] is not necessary.
             */
            get actionName(): string;
            set actionName(val: string);
            /**
             * The text direction for which this shortcut is active.
             *
             * If the shortcut is used regardless of the text direction,
             * set this property to %GTK_TEXT_DIR_NONE.
             */
            get direction(): TextDirection;
            set direction(val: TextDirection);
            /**
             * An icon to represent the shortcut or gesture.
             *
             * This property is used if [property`Gtk`.ShortcutsShortcut:shortcut-type]
             * is set to %GTK_SHORTCUT_GESTURE.
             *
             * For the other predefined gesture types, GTK provides an icon on its own.
             */
            get icon(): Gio.Icon;
            set icon(val: Gio.Icon);
            /**
             * %TRUE if an icon has been set.
             */
            get icon_set(): boolean;
            set icon_set(val: boolean);
            /**
             * %TRUE if an icon has been set.
             */
            get iconSet(): boolean;
            set iconSet(val: boolean);
            /**
             * The type of shortcut that is represented.
             */
            get shortcut_type(): ShortcutType;
            set shortcut_type(val: ShortcutType);
            /**
             * The type of shortcut that is represented.
             */
            get shortcutType(): ShortcutType;
            set shortcutType(val: ShortcutType);
            /**
             * The subtitle for the shortcut or gesture.
             *
             * This is typically used for gestures and should be a short, one-line
             * text that describes the gesture itself. For the predefined gesture
             * types, GTK provides a subtitle on its own.
             */
            get subtitle(): string;
            set subtitle(val: string);
            /**
             * %TRUE if a subtitle has been set.
             */
            get subtitle_set(): boolean;
            set subtitle_set(val: boolean);
            /**
             * %TRUE if a subtitle has been set.
             */
            get subtitleSet(): boolean;
            set subtitleSet(val: boolean);
            /**
             * The textual description for the shortcut or gesture represented by
             * this object.
             *
             * This should be a short string that can fit in a single line.
             */
            get title(): string;
            set title(val: string);
            /**
             * The size group for the textual portion of this shortcut.
             *
             * This is used internally by GTK, and must not be modified by applications.
             */
            set title_size_group(val: SizeGroup);
            /**
             * The size group for the textual portion of this shortcut.
             *
             * This is used internally by GTK, and must not be modified by applications.
             */
            set titleSizeGroup(val: SizeGroup);

            // Constructors

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

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

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ShortcutsWindow {
            // Signal callback interfaces

            interface Close {
                (): void;
            }

            interface Search {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Window.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Native.ConstructorProps,
                    Root.ConstructorProps,
                    ShortcutManager.ConstructorProps {
                section_name: string;
                sectionName: string;
                view_name: string;
                viewName: string;
            }
        }

        /**
         * A `GtkShortcutsWindow` shows information about the keyboard shortcuts
         * and gestures of an application.
         *
         * The shortcuts can be grouped, and you can have multiple sections in this
         * window, corresponding to the major modes of your application.
         *
         * Additionally, the shortcuts can be filtered by the current view, to avoid
         * showing information that is not relevant in the current application context.
         *
         * The recommended way to construct a `GtkShortcutsWindow` is with
         * [class`Gtk`.Builder], by using the `<child>` tag to populate a
         * `GtkShortcutsWindow` with one or more [class`Gtk`.ShortcutsSection] objects,
         * which contain one or more [class`Gtk`.ShortcutsGroup] instances, which, in turn,
         * contain [class`Gtk`.ShortcutsShortcut] instances.
         *
         * If you need to add a section programmatically, use [method`Gtk`.ShortcutsWindow.add_section]
         * instead of [method`Gtk`.Window.set_child], as the shortcuts window manages
         * its children directly.
         *
         * # A simple example:
         *
         * ![](gedit-shortcuts.png)
         *
         * This example has as single section. As you can see, the shortcut groups
         * are arranged in columns, and spread across several pages if there are too
         * many to find on a single page.
         *
         * The .ui file for this example can be found [here](https://gitlab.gnome.org/GNOME/gtk/tree/main/demos/gtk-demo/shortcuts-gedit.ui).
         *
         * # An example with multiple views:
         *
         * ![](clocks-shortcuts.png)
         *
         * This example shows a `GtkShortcutsWindow` that has been configured to show only
         * the shortcuts relevant to the "stopwatch" view.
         *
         * The .ui file for this example can be found [here](https://gitlab.gnome.org/GNOME/gtk/tree/main/demos/gtk-demo/shortcuts-clocks.ui).
         *
         * # An example with multiple sections:
         *
         * ![](builder-shortcuts.png)
         *
         * This example shows a `GtkShortcutsWindow` with two sections, "Editor Shortcuts"
         * and "Terminal Shortcuts".
         *
         * The .ui file for this example can be found [here](https://gitlab.gnome.org/GNOME/gtk/tree/main/demos/gtk-demo/shortcuts-builder.ui).
         *
         * # Shortcuts and Gestures
         *
         * The following signals have default keybindings:
         *
         * - [signal`Gtk`.ShortcutsWindow::close]
         * - [signal`Gtk`.ShortcutsWindow::search]
         *
         * # CSS nodes
         *
         * `GtkShortcutsWindow` has a single CSS node with the name `window` and style
         * class `.shortcuts`.
         */
        class ShortcutsWindow
            extends Window
            implements Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager
        {
            static $gtype: GObject.GType<ShortcutsWindow>;

            // Properties

            /**
             * The name of the section to show.
             *
             * This should be the section-name of one of the `GtkShortcutsSection`
             * objects that are in this shortcuts window.
             */
            get section_name(): string;
            set section_name(val: string);
            /**
             * The name of the section to show.
             *
             * This should be the section-name of one of the `GtkShortcutsSection`
             * objects that are in this shortcuts window.
             */
            get sectionName(): string;
            set sectionName(val: string);
            /**
             * The view name by which to filter the contents.
             *
             * This should correspond to the [property`Gtk`.ShortcutsGroup:view]
             * property of some of the [class`Gtk`.ShortcutsGroup] objects that
             * are inside this shortcuts window.
             *
             * Set this to %NULL to show all groups.
             */
            get view_name(): string;
            set view_name(val: string);
            /**
             * The view name by which to filter the contents.
             *
             * This should correspond to the [property`Gtk`.ShortcutsGroup:view]
             * property of some of the [class`Gtk`.ShortcutsGroup] objects that
             * are inside this shortcuts window.
             *
             * Set this to %NULL to show all groups.
             */
            get viewName(): string;
            set viewName(val: string);

            // Constructors

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

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

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'close', callback: (_source: this) => void): number;
            connect_after(signal: 'close', callback: (_source: this) => void): number;
            emit(signal: 'close'): void;
            connect(signal: 'search', callback: (_source: this) => void): number;
            connect_after(signal: 'search', callback: (_source: this) => void): number;
            emit(signal: 'search'): void;

            // Methods

            /**
             * Adds a section to the shortcuts window.
             *
             * This is the programmatic equivalent to using [class`Gtk`.Builder] and a
             * `<child>` tag to add the child.
             *
             * Using [method`Gtk`.Window.set_child] is not appropriate as the shortcuts
             * window manages its children internally.
             * @param section the `GtkShortcutsSection` to add
             */
            add_section(section: ShortcutsSection): void;

            // Inherited properties
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Returns the renderer that is used for this `GtkNative`.
             * @returns the renderer for @self
             */
            get_renderer(): Gsk.Renderer | null;
            /**
             * Returns the surface of this `GtkNative`.
             * @returns the surface of @self
             */
            get_surface(): Gdk.Surface | null;
            /**
             * Retrieves the surface transform of `self`.
             *
             * This is the translation from `self'`s surface coordinates into
             * `self'`s widget coordinates.
             */
            get_surface_transform(): [number, number];
            /**
             * Realizes a `GtkNative`.
             *
             * This should only be used by subclasses.
             */
            realize(): void;
            /**
             * Unrealizes a `GtkNative`.
             *
             * This should only be used by subclasses.
             */
            unrealize(): void;
            /**
             * Returns the display that this `GtkRoot` is on.
             * @returns the display of @root
             */
            get_display(): Gdk.Display;
            /**
             * Retrieves the current focused widget within the root.
             *
             * Note that this is the widget that would have the focus
             * if the root is active; if the root is not focused then
             * `gtk_widget_has_focus (widget)` will be %FALSE for the
             * widget.
             * @returns the currently focused widget
             */
            get_focus(): Widget | null;
            /**
             * If `focus` is not the current focus widget, and is focusable, sets
             * it as the focus widget for the root.
             *
             * If `focus` is %NULL, unsets the focus widget for the root.
             *
             * To set the focus to a particular widget in the root, it is usually
             * more convenient to use [method`Gtk`.Widget.grab_focus] instead of
             * this function.
             * @param focus widget to be the new focus widget, or %NULL    to unset the focus widget
             */
            set_focus(focus?: Widget | null): void;
            /**
             * Add a `GtkShortcutController` to be managed.
             * @param controller
             */
            vfunc_add_controller(controller: ShortcutController): void;
            /**
             * Remove a `GtkShortcutController` that had previously
             *   been added
             * @param controller
             */
            vfunc_remove_controller(controller: ShortcutController): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace SignalAction {
            // Constructor properties interface

            interface ConstructorProps extends ShortcutAction.ConstructorProps {
                signal_name: string;
                signalName: string;
            }
        }

        /**
         * A `GtkShortcut`Action that emits a signal.
         *
         * Signals that are used in this way are referred to as keybinding signals,
         * and they are expected to be defined with the %G_SIGNAL_ACTION flag.
         */
        class SignalAction extends ShortcutAction {
            static $gtype: GObject.GType<SignalAction>;

            // Properties

            /**
             * The name of the signal to emit.
             */
            get signal_name(): string;
            /**
             * The name of the signal to emit.
             */
            get signalName(): string;

            // Constructors

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

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

            static ['new'](signal_name: string): SignalAction;

            // Methods

            /**
             * Returns the name of the signal that will be emitted.
             * @returns the name of the signal to emit
             */
            get_signal_name(): string;
        }

        namespace SignalListItemFactory {
            // Signal callback interfaces

            interface Bind {
                (object: GObject.Object): void;
            }

            interface Setup {
                (object: GObject.Object): void;
            }

            interface Teardown {
                (object: GObject.Object): void;
            }

            interface Unbind {
                (object: GObject.Object): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends ListItemFactory.ConstructorProps {}
        }

        /**
         * `GtkSignalListItemFactory` is a `GtkListItemFactory` that emits signals
         * to manage listitems.
         *
         * Signals are emitted for every listitem in the same order:
         *
         *  1. [signal`Gtk`.SignalListItemFactory::setup] is emitted to set up permanent
         *  things on the listitem. This usually means constructing the widgets used in
         *  the row and adding them to the listitem.
         *
         *  2. [signal`Gtk`.SignalListItemFactory::bind] is emitted to bind the item passed
         *  via [property`Gtk`.ListItem:item] to the widgets that have been created in
         *  step 1 or to add item-specific widgets. Signals are connected to listen to
         *  changes - both to changes in the item to update the widgets or to changes
         *  in the widgets to update the item. After this signal has been called, the
         *  listitem may be shown in a list widget.
         *
         *  3. [signal`Gtk`.SignalListItemFactory::unbind] is emitted to undo everything
         *  done in step 2. Usually this means disconnecting signal handlers. Once this
         *  signal has been called, the listitem will no longer be used in a list
         *  widget.
         *
         *  4. [signal`Gtk`.SignalListItemFactory::bind] and
         *  [signal`Gtk`.SignalListItemFactory::unbind] may be emitted multiple times
         *  again to bind the listitem for use with new items. By reusing listitems,
         *  potentially costly setup can be avoided. However, it means code needs to
         *  make sure to properly clean up the listitem in step 3 so that no information
         *  from the previous use leaks into the next use.
         *
         * 5. [signal`Gtk`.SignalListItemFactory::teardown] is emitted to allow undoing
         * the effects of [signal`Gtk`.SignalListItemFactory::setup]. After this signal
         * was emitted on a listitem, the listitem will be destroyed and not be used again.
         *
         * Note that during the signal emissions, changing properties on the
         * listitems passed will not trigger notify signals as the listitem's
         * notifications are frozen. See g_object_freeze_notify() for details.
         *
         * For tracking changes in other properties in the listitem, the
         * ::notify signal is recommended. The signal can be connected in the
         * [signal`Gtk`.SignalListItemFactory::setup] signal and removed again during
         * [signal`Gtk`.SignalListItemFactory::teardown].
         */
        class SignalListItemFactory extends ListItemFactory {
            static $gtype: GObject.GType<SignalListItemFactory>;

            // Constructors

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

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

            static ['new'](): SignalListItemFactory;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'bind', callback: (_source: this, object: GObject.Object) => void): number;
            connect_after(signal: 'bind', callback: (_source: this, object: GObject.Object) => void): number;
            emit(signal: 'bind', object: GObject.Object): void;
            connect(signal: 'setup', callback: (_source: this, object: GObject.Object) => void): number;
            connect_after(signal: 'setup', callback: (_source: this, object: GObject.Object) => void): number;
            emit(signal: 'setup', object: GObject.Object): void;
            connect(signal: 'teardown', callback: (_source: this, object: GObject.Object) => void): number;
            connect_after(signal: 'teardown', callback: (_source: this, object: GObject.Object) => void): number;
            emit(signal: 'teardown', object: GObject.Object): void;
            connect(signal: 'unbind', callback: (_source: this, object: GObject.Object) => void): number;
            connect_after(signal: 'unbind', callback: (_source: this, object: GObject.Object) => void): number;
            emit(signal: 'unbind', object: GObject.Object): void;
        }

        namespace SingleSelection {
            // Constructor properties interface

            interface ConstructorProps<A extends GObject.Object = GObject.Object>
                extends GObject.Object.ConstructorProps,
                    Gio.ListModel.ConstructorProps,
                    SectionModel.ConstructorProps,
                    SelectionModel.ConstructorProps {
                autoselect: boolean;
                can_unselect: boolean;
                canUnselect: boolean;
                item_type: GObject.GType;
                itemType: GObject.GType;
                model: Gio.ListModel;
                n_items: number;
                nItems: number;
                selected: number;
                selected_item: GObject.Object;
                selectedItem: GObject.Object;
            }
        }

        /**
         * `GtkSingleSelection` is a `GtkSelectionModel` that allows selecting a single
         * item.
         *
         * Note that the selection is *persistent* -- if the selected item is removed
         * and re-added in the same [signal`Gio`.ListModel::items-changed] emission, it
         * stays selected. In particular, this means that changing the sort order of an
         * underlying sort model will preserve the selection.
         */
        class SingleSelection<A extends GObject.Object = GObject.Object>
            extends GObject.Object
            implements Gio.ListModel<A>, SectionModel, SelectionModel
        {
            static $gtype: GObject.GType<SingleSelection>;

            // Properties

            /**
             * If the selection will always select an item.
             */
            get autoselect(): boolean;
            set autoselect(val: boolean);
            /**
             * If unselecting the selected item is allowed.
             */
            get can_unselect(): boolean;
            set can_unselect(val: boolean);
            /**
             * If unselecting the selected item is allowed.
             */
            get canUnselect(): boolean;
            set canUnselect(val: boolean);
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get item_type(): GObject.GType;
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get itemType(): GObject.GType;
            /**
             * The model being managed.
             */
            get model(): Gio.ListModel;
            set model(val: Gio.ListModel);
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get n_items(): number;
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get nItems(): number;
            /**
             * Position of the selected item.
             */
            get selected(): number;
            set selected(val: number);
            /**
             * The selected item.
             */
            get selected_item(): GObject.Object;
            /**
             * The selected item.
             */
            get selectedItem(): GObject.Object;

            // Constructors

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

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

            static ['new'](model?: Gio.ListModel | null): SingleSelection;

            // Methods

            /**
             * Checks if autoselect has been enabled or disabled via
             * gtk_single_selection_set_autoselect().
             * @returns %TRUE if autoselect is enabled
             */
            get_autoselect(): boolean;
            /**
             * If %TRUE, gtk_selection_model_unselect_item() is supported and allows
             * unselecting the selected item.
             * @returns %TRUE to support unselecting
             */
            get_can_unselect(): boolean;
            /**
             * Gets the model that `self` is wrapping.
             * @returns The model being wrapped
             */
            get_model(): Gio.ListModel | null;
            /**
             * Gets the position of the selected item.
             *
             * If no item is selected, %GTK_INVALID_LIST_POSITION is returned.
             * @returns The position of the selected item
             */
            get_selected(): number;
            /**
             * Gets the selected item.
             *
             * If no item is selected, %NULL is returned.
             * @returns The selected item
             */
            get_selected_item<T = GObject.Object>(): T;
            /**
             * Enables or disables autoselect.
             *
             * If `autoselect` is %TRUE, `self` will enforce that an item is always
             * selected. It will select a new item when the currently selected
             * item is deleted and it will disallow unselecting the current item.
             * @param autoselect %TRUE to always select an item
             */
            set_autoselect(autoselect: boolean): void;
            /**
             * If %TRUE, unselecting the current item via
             * gtk_selection_model_unselect_item() is supported.
             *
             * Note that setting [property`Gtk`.SingleSelection:autoselect] will
             * cause unselecting to not work, so it practically makes no sense
             * to set both at the same time.
             * @param can_unselect %TRUE to allow unselecting
             */
            set_can_unselect(can_unselect: boolean): void;
            /**
             * Sets the model that `self` should wrap.
             *
             * If `model` is %NULL, `self` will be empty.
             * @param model A `GListModel` to wrap
             */
            set_model(model?: Gio.ListModel | null): void;
            /**
             * Selects the item at the given position.
             *
             * If the list does not have an item at `position` or
             * %GTK_INVALID_LIST_POSITION is given, the behavior depends on the
             * value of the [property`Gtk`.SingleSelection:autoselect] property:
             * If it is set, no change will occur and the old item will stay
             * selected. If it is unset, the selection will be unset and no item
             * will be selected. This also applies if [property`Gtk`.SingleSelection:can-unselect]
             * is set to %FALSE.
             * @param position the item to select or %GTK_INVALID_LIST_POSITION
             */
            set_selected(position: number): void;

            // Inherited methods
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             * @returns the #GType of the items contained in @list.
             */
            get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             * @returns the number of items in @list.
             */
            get_n_items(): number;
            /**
             * Get the item at `position`.
             *
             * If `position` is greater than the number of items in `list,` %NULL is
             * returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.
             *
             * This function is meant to be used by language bindings in place
             * of g_list_model_get_item().
             *
             * See also: g_list_model_get_n_items()
             * @param position the position of the item to fetch
             * @returns the object at @position.
             */
            get_item(position: number): A | null;
            /**
             * Emits the #GListModel::items-changed signal on `list`.
             *
             * This function should only be called by classes implementing
             * #GListModel. It has to be called after the internal representation
             * of `list` has been updated, because handlers connected to this signal
             * might query the new state of the list.
             *
             * Implementations must only make changes to the model (as visible to
             * its consumer) in places that will not cause problems for that
             * consumer.  For models that are driven directly by a write API (such
             * as #GListStore), changes can be reported in response to uses of that
             * API.  For models that represent remote data, changes should only be
             * made from a fresh mainloop dispatch.  It is particularly not
             * permitted to make changes in response to a call to the #GListModel
             * consumer API.
             *
             * Stated another way: in general, it is assumed that code making a
             * series of accesses to the model via the API, without returning to the
             * mainloop, and without calling other code, will continue to view the
             * same contents of the model.
             * @param position the position at which @list changed
             * @param removed the number of items removed
             * @param added the number of items added
             */
            items_changed(position: number, removed: number, added: number): void;
            /**
             * Get the item at `position`. If `position` is greater than the number of
             * items in `list,` %NULL is returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.  See g_list_model_get_n_items().
             *
             * The same #GObject instance may not appear more than once in a #GListModel.
             * @param position the position of the item to fetch
             */
            vfunc_get_item(position: number): A | null;
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             */
            vfunc_get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             */
            vfunc_get_n_items(): number;
            /**
             * Query the section that covers the given position. The number of
             * items in the section can be computed by `out_end - out_start`.
             *
             * If the position is larger than the number of items, a single
             * range from n_items to G_MAXUINT will be returned.
             * @param position the position of the item to query
             */
            get_section(position: number): [number, number];
            /**
             * This function emits the [signal`Gtk`.SectionModel::sections-changed]
             * signal to notify about changes to sections.
             *
             * It must cover all positions that used to be a section start or that
             * are now a section start. It does not have to cover all positions for
             * which the section has changed.
             *
             * The [signal`Gio`.ListModel::items-changed] implies the effect of the
             * [signal`Gtk`.SectionModel::sections-changed] signal for all the items
             * it covers.
             *
             * It is recommended that when changes to the items cause section changes
             * in a larger range, that the larger range is included in the emission
             * of the [signal`Gio`.ListModel::items-changed] instead of emitting
             * two signals.
             * @param position the first changed item
             * @param n_items the number of changed items
             */
            sections_changed(position: number, n_items: number): void;
            /**
             * Query the section that covers the given position. The number of
             * items in the section can be computed by `out_end - out_start`.
             *
             * If the position is larger than the number of items, a single
             * range from n_items to G_MAXUINT will be returned.
             * @param position the position of the item to query
             */
            vfunc_get_section(position: number): [number, number];
            /**
             * Gets the set containing all currently selected items in the model.
             *
             * This function may be slow, so if you are only interested in single item,
             * consider using [method`Gtk`.SelectionModel.is_selected] or if you are only
             * interested in a few, consider [method`Gtk`.SelectionModel.get_selection_in_range].
             * @returns a `GtkBitset` containing all the values currently   selected in @model. If no items are selected, the bitset is empty.   The bitset must not be modified.
             */
            get_selection(): Bitset;
            /**
             * Gets the set of selected items in a range.
             *
             * This function is an optimization for
             * [method`Gtk`.SelectionModel.get_selection] when you are only
             * interested in part of the model's selected state. A common use
             * case is in response to the [signal`Gtk`.SelectionModel::selection-changed]
             * signal.
             * @param position start of the queried range
             * @param n_items number of items in the queried range
             * @returns A `GtkBitset` that matches the selection state   for the given range with all other values being undefined.   The bitset must not be modified.
             */
            get_selection_in_range(position: number, n_items: number): Bitset;
            /**
             * Checks if the given item is selected.
             * @param position the position of the item to query
             * @returns %TRUE if the item is selected
             */
            is_selected(position: number): boolean;
            /**
             * Requests to select all items in the model.
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items are now selected.
             */
            select_all(): boolean;
            /**
             * Requests to select an item in the model.
             * @param position the position of the item to select
             * @param unselect_rest whether previously selected items should be unselected
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the item was selected.
             */
            select_item(position: number, unselect_rest: boolean): boolean;
            /**
             * Requests to select a range of items in the model.
             * @param position the first item to select
             * @param n_items the number of items to select
             * @param unselect_rest whether previously selected items should be unselected
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the range was selected.
             */
            select_range(position: number, n_items: number, unselect_rest: boolean): boolean;
            /**
             * Helper function for implementations of `GtkSelectionModel`.
             *
             * Call this when the selection changes to emit the
             * [signal`Gtk`.SelectionModel::selection-changed] signal.
             * @param position the first changed item
             * @param n_items the number of changed items
             */
            selection_changed(position: number, n_items: number): void;
            /**
             * Make selection changes.
             *
             * This is the most advanced selection updating method that allows
             * the most fine-grained control over selection changes. If you can,
             * you should try the simpler versions, as implementations are more
             * likely to implement support for those.
             *
             * Requests that the selection state of all positions set in `mask`
             * be updated to the respective value in the `selected` bitmask.
             *
             * In pseudocode, it would look something like this:
             *
             * ```c
             * for (i = 0; i < n_items; i++)
             *   {
             *     // don't change values not in the mask
             *     if (!gtk_bitset_contains (mask, i))
             *       continue;
             *
             *     if (gtk_bitset_contains (selected, i))
             *       select_item (i);
             *     else
             *       unselect_item (i);
             *   }
             *
             * gtk_selection_model_selection_changed (model,
             *                                        first_changed_item,
             *                                        n_changed_items);
             * ```
             *
             * `mask` and `selected` must not be modified. They may refer to the
             * same bitset, which would mean that every item in the set should
             * be selected.
             * @param selected bitmask specifying if items should be selected or unselected
             * @param mask bitmask specifying which items should be updated
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items were updated according   to the inputs.
             */
            set_selection(selected: Bitset, mask: Bitset): boolean;
            /**
             * Requests to unselect all items in the model.
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items are now unselected.
             */
            unselect_all(): boolean;
            /**
             * Requests to unselect an item in the model.
             * @param position the position of the item to unselect
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the item was unselected.
             */
            unselect_item(position: number): boolean;
            /**
             * Requests to unselect a range of items in the model.
             * @param position the first item to unselect
             * @param n_items the number of items to unselect
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the range was unselected.
             */
            unselect_range(position: number, n_items: number): boolean;
            /**
             * Gets the set of selected items in a range.
             *
             * This function is an optimization for
             * [method`Gtk`.SelectionModel.get_selection] when you are only
             * interested in part of the model's selected state. A common use
             * case is in response to the [signal`Gtk`.SelectionModel::selection-changed]
             * signal.
             * @param position start of the queried range
             * @param n_items number of items in the queried range
             */
            vfunc_get_selection_in_range(position: number, n_items: number): Bitset;
            /**
             * Checks if the given item is selected.
             * @param position the position of the item to query
             */
            vfunc_is_selected(position: number): boolean;
            /**
             * Requests to select all items in the model.
             */
            vfunc_select_all(): boolean;
            /**
             * Requests to select an item in the model.
             * @param position the position of the item to select
             * @param unselect_rest whether previously selected items should be unselected
             */
            vfunc_select_item(position: number, unselect_rest: boolean): boolean;
            /**
             * Requests to select a range of items in the model.
             * @param position the first item to select
             * @param n_items the number of items to select
             * @param unselect_rest whether previously selected items should be unselected
             */
            vfunc_select_range(position: number, n_items: number, unselect_rest: boolean): boolean;
            /**
             * Make selection changes.
             *
             * This is the most advanced selection updating method that allows
             * the most fine-grained control over selection changes. If you can,
             * you should try the simpler versions, as implementations are more
             * likely to implement support for those.
             *
             * Requests that the selection state of all positions set in `mask`
             * be updated to the respective value in the `selected` bitmask.
             *
             * In pseudocode, it would look something like this:
             *
             * ```c
             * for (i = 0; i < n_items; i++)
             *   {
             *     // don't change values not in the mask
             *     if (!gtk_bitset_contains (mask, i))
             *       continue;
             *
             *     if (gtk_bitset_contains (selected, i))
             *       select_item (i);
             *     else
             *       unselect_item (i);
             *   }
             *
             * gtk_selection_model_selection_changed (model,
             *                                        first_changed_item,
             *                                        n_changed_items);
             * ```
             *
             * `mask` and `selected` must not be modified. They may refer to the
             * same bitset, which would mean that every item in the set should
             * be selected.
             * @param selected bitmask specifying if items should be selected or unselected
             * @param mask bitmask specifying which items should be updated
             */
            vfunc_set_selection(selected: Bitset, mask: Bitset): boolean;
            /**
             * Requests to unselect all items in the model.
             */
            vfunc_unselect_all(): boolean;
            /**
             * Requests to unselect an item in the model.
             * @param position the position of the item to unselect
             */
            vfunc_unselect_item(position: number): boolean;
            /**
             * Requests to unselect a range of items in the model.
             * @param position the first item to unselect
             * @param n_items the number of items to unselect
             */
            vfunc_unselect_range(position: number, n_items: number): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace SizeGroup {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps, Buildable.ConstructorProps {
                mode: SizeGroupMode;
            }
        }

        /**
         * `GtkSizeGroup` groups widgets together so they all request the same size.
         *
         * This is typically useful when you want a column of widgets to have the
         * same size, but you can’t use a `GtkGrid`.
         *
         * In detail, the size requested for each widget in a `GtkSizeGroup` is
         * the maximum of the sizes that would have been requested for each
         * widget in the size group if they were not in the size group. The mode
         * of the size group (see [method`Gtk`.SizeGroup.set_mode]) determines whether
         * this applies to the horizontal size, the vertical size, or both sizes.
         *
         * Note that size groups only affect the amount of space requested, not
         * the size that the widgets finally receive. If you want the widgets in
         * a `GtkSizeGroup` to actually be the same size, you need to pack them in
         * such a way that they get the size they request and not more.
         *
         * `GtkSizeGroup` objects are referenced by each widget in the size group,
         * so once you have added all widgets to a `GtkSizeGroup`, you can drop
         * the initial reference to the size group with g_object_unref(). If the
         * widgets in the size group are subsequently destroyed, then they will
         * be removed from the size group and drop their references on the size
         * group; when all widgets have been removed, the size group will be
         * freed.
         *
         * Widgets can be part of multiple size groups; GTK will compute the
         * horizontal size of a widget from the horizontal requisition of all
         * widgets that can be reached from the widget by a chain of size groups
         * of type %GTK_SIZE_GROUP_HORIZONTAL or %GTK_SIZE_GROUP_BOTH, and the
         * vertical size from the vertical requisition of all widgets that can be
         * reached from the widget by a chain of size groups of type
         * %GTK_SIZE_GROUP_VERTICAL or %GTK_SIZE_GROUP_BOTH.
         *
         * Note that only non-contextual sizes of every widget are ever consulted
         * by size groups (since size groups have no knowledge of what size a widget
         * will be allocated in one dimension, it cannot derive how much height
         * a widget will receive for a given width). When grouping widgets that
         * trade height for width in mode %GTK_SIZE_GROUP_VERTICAL or %GTK_SIZE_GROUP_BOTH:
         * the height for the minimum width will be the requested height for all
         * widgets in the group. The same is of course true when horizontally grouping
         * width for height widgets.
         *
         * Widgets that trade height-for-width should set a reasonably large minimum
         * width by way of [property`Gtk`.Label:width-chars] for instance. Widgets with
         * static sizes as well as widgets that grow (such as ellipsizing text) need no
         * such considerations.
         *
         * # GtkSizeGroup as GtkBuildable
         *
         * Size groups can be specified in a UI definition by placing an `<object>`
         * element with `class="GtkSizeGroup"` somewhere in the UI definition. The
         * widgets that belong to the size group are specified by a `<widgets>` element
         * that may contain multiple `<widget>` elements, one for each member of the
         * size group. The ”name” attribute gives the id of the widget.
         *
         * An example of a UI definition fragment with `GtkSizeGroup`:
         * ```xml
         * <object class="GtkSizeGroup">
         *   <property name="mode">horizontal</property>
         *   <widgets>
         *     <widget name="radio1"/>
         *     <widget name="radio2"/>
         *   </widgets>
         * </object>
         * ```
         */
        class SizeGroup extends GObject.Object implements Buildable {
            static $gtype: GObject.GType<SizeGroup>;

            // Properties

            /**
             * The direction in which the size group affects requested sizes.
             */
            get mode(): SizeGroupMode;
            set mode(val: SizeGroupMode);

            // Constructors

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

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

            static ['new'](mode: SizeGroupMode): SizeGroup;

            // Methods

            /**
             * Adds a widget to a `GtkSizeGroup`.
             *
             * In the future, the requisition
             * of the widget will be determined as the maximum of its requisition
             * and the requisition of the other widgets in the size group.
             * Whether this applies horizontally, vertically, or in both directions
             * depends on the mode of the size group.
             * See [method`Gtk`.SizeGroup.set_mode].
             *
             * When the widget is destroyed or no longer referenced elsewhere, it
             * will be removed from the size group.
             * @param widget the `GtkWidget` to add
             */
            add_widget(widget: Widget): void;
            /**
             * Gets the current mode of the size group.
             * @returns the current mode of the size group.
             */
            get_mode(): SizeGroupMode;
            /**
             * Returns the list of widgets associated with `size_group`.
             * @returns a `GSList` of   widgets. The list is owned by GTK and should not be modified.
             */
            get_widgets(): Widget[];
            /**
             * Removes a widget from a `GtkSizeGroup`.
             * @param widget the `GtkWidget` to remove
             */
            remove_widget(widget: Widget): void;
            /**
             * Sets the `GtkSizeGroupMode` of the size group.
             *
             * The mode of the size group determines whether the widgets in the
             * size group should all have the same horizontal requisition
             * (%GTK_SIZE_GROUP_HORIZONTAL) all have the same vertical requisition
             * (%GTK_SIZE_GROUP_VERTICAL), or should all have the same requisition
             * in both directions (%GTK_SIZE_GROUP_BOTH).
             * @param mode the mode to set for the size group.
             */
            set_mode(mode: SizeGroupMode | null): void;

            // Inherited methods
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace SliceListModel {
            // Constructor properties interface

            interface ConstructorProps<A extends GObject.Object = GObject.Object>
                extends GObject.Object.ConstructorProps,
                    Gio.ListModel.ConstructorProps,
                    SectionModel.ConstructorProps {
                item_type: GObject.GType;
                itemType: GObject.GType;
                model: Gio.ListModel;
                n_items: number;
                nItems: number;
                offset: number;
                size: number;
            }
        }

        /**
         * `GtkSliceListModel` is a list model that presents a slice of another model.
         *
         * This is useful when implementing paging by setting the size to the number
         * of elements per page and updating the offset whenever a different page is
         * opened.
         *
         * `GtkSliceListModel` passes through sections from the underlying model.
         */
        class SliceListModel<A extends GObject.Object = GObject.Object>
            extends GObject.Object
            implements Gio.ListModel<A>, SectionModel
        {
            static $gtype: GObject.GType<SliceListModel>;

            // Properties

            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get item_type(): GObject.GType;
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get itemType(): GObject.GType;
            /**
             * Child model to take slice from.
             */
            get model(): Gio.ListModel;
            set model(val: Gio.ListModel);
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get n_items(): number;
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get nItems(): number;
            /**
             * Offset of slice.
             */
            get offset(): number;
            set offset(val: number);
            /**
             * Maximum size of slice.
             */
            get size(): number;
            set size(val: number);

            // Constructors

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

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

            static ['new'](model: Gio.ListModel | null, offset: number, size: number): SliceListModel;

            // Methods

            /**
             * Gets the model that is currently being used or %NULL if none.
             * @returns The model in use
             */
            get_model(): Gio.ListModel | null;
            /**
             * Gets the offset set via gtk_slice_list_model_set_offset().
             * @returns The offset
             */
            get_offset(): number;
            /**
             * Gets the size set via gtk_slice_list_model_set_size().
             * @returns The size
             */
            get_size(): number;
            /**
             * Sets the model to show a slice of.
             *
             * The model's item type must conform to `self'`s item type.
             * @param model The model to be sliced
             */
            set_model(model?: Gio.ListModel | null): void;
            /**
             * Sets the offset into the original model for this slice.
             *
             * If the offset is too large for the sliced model,
             * `self` will end up empty.
             * @param offset the new offset to use
             */
            set_offset(offset: number): void;
            /**
             * Sets the maximum size. `self` will never have more items
             * than `size`.
             *
             * It can however have fewer items if the offset is too large
             * or the model sliced from doesn't have enough items.
             * @param size the maximum size
             */
            set_size(size: number): void;

            // Inherited methods
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             * @returns the #GType of the items contained in @list.
             */
            get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             * @returns the number of items in @list.
             */
            get_n_items(): number;
            /**
             * Get the item at `position`.
             *
             * If `position` is greater than the number of items in `list,` %NULL is
             * returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.
             *
             * This function is meant to be used by language bindings in place
             * of g_list_model_get_item().
             *
             * See also: g_list_model_get_n_items()
             * @param position the position of the item to fetch
             * @returns the object at @position.
             */
            get_item(position: number): A | null;
            /**
             * Emits the #GListModel::items-changed signal on `list`.
             *
             * This function should only be called by classes implementing
             * #GListModel. It has to be called after the internal representation
             * of `list` has been updated, because handlers connected to this signal
             * might query the new state of the list.
             *
             * Implementations must only make changes to the model (as visible to
             * its consumer) in places that will not cause problems for that
             * consumer.  For models that are driven directly by a write API (such
             * as #GListStore), changes can be reported in response to uses of that
             * API.  For models that represent remote data, changes should only be
             * made from a fresh mainloop dispatch.  It is particularly not
             * permitted to make changes in response to a call to the #GListModel
             * consumer API.
             *
             * Stated another way: in general, it is assumed that code making a
             * series of accesses to the model via the API, without returning to the
             * mainloop, and without calling other code, will continue to view the
             * same contents of the model.
             * @param position the position at which @list changed
             * @param removed the number of items removed
             * @param added the number of items added
             */
            items_changed(position: number, removed: number, added: number): void;
            /**
             * Get the item at `position`. If `position` is greater than the number of
             * items in `list,` %NULL is returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.  See g_list_model_get_n_items().
             *
             * The same #GObject instance may not appear more than once in a #GListModel.
             * @param position the position of the item to fetch
             */
            vfunc_get_item(position: number): A | null;
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             */
            vfunc_get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             */
            vfunc_get_n_items(): number;
            /**
             * Query the section that covers the given position. The number of
             * items in the section can be computed by `out_end - out_start`.
             *
             * If the position is larger than the number of items, a single
             * range from n_items to G_MAXUINT will be returned.
             * @param position the position of the item to query
             */
            get_section(position: number): [number, number];
            /**
             * This function emits the [signal`Gtk`.SectionModel::sections-changed]
             * signal to notify about changes to sections.
             *
             * It must cover all positions that used to be a section start or that
             * are now a section start. It does not have to cover all positions for
             * which the section has changed.
             *
             * The [signal`Gio`.ListModel::items-changed] implies the effect of the
             * [signal`Gtk`.SectionModel::sections-changed] signal for all the items
             * it covers.
             *
             * It is recommended that when changes to the items cause section changes
             * in a larger range, that the larger range is included in the emission
             * of the [signal`Gio`.ListModel::items-changed] instead of emitting
             * two signals.
             * @param position the first changed item
             * @param n_items the number of changed items
             */
            sections_changed(position: number, n_items: number): void;
            /**
             * Query the section that covers the given position. The number of
             * items in the section can be computed by `out_end - out_start`.
             *
             * If the position is larger than the number of items, a single
             * range from n_items to G_MAXUINT will be returned.
             * @param position the position of the item to query
             */
            vfunc_get_section(position: number): [number, number];
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Snapshot {
            // Constructor properties interface

            interface ConstructorProps extends Gdk.Snapshot.ConstructorProps {}
        }

        /**
         * `GtkSnapshot` assists in creating [class`Gsk`.RenderNode]s for widgets.
         *
         * It functions in a similar way to a cairo context, and maintains a stack
         * of render nodes and their associated transformations.
         *
         * The node at the top of the stack is the one that `gtk_snapshot_append_…()`
         * functions operate on. Use the `gtk_snapshot_push_…()` functions and
         * [method`Snapshot`.pop] to change the current node.
         *
         * The typical way to obtain a `GtkSnapshot` object is as an argument to
         * the [vfunc`Gtk`.Widget.snapshot] vfunc. If you need to create your own
         * `GtkSnapshot`, use [ctor`Gtk`.Snapshot.new].
         */
        class Snapshot extends Gdk.Snapshot {
            static $gtype: GObject.GType<Snapshot>;

            // Constructors

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

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

            static ['new'](): Snapshot;

            // Methods

            /**
             * Appends a stroked border rectangle inside the given `outline`.
             *
             * The four sides of the border can have different widths and colors.
             * @param outline the outline of the border
             * @param border_width the stroke width of the border on   the top, right, bottom and left side respectively.
             * @param border_color the color used on the top, right,   bottom and left side.
             */
            append_border(outline: Gsk.RoundedRect, border_width: number[], border_color: Gdk.RGBA[]): void;
            /**
             * Creates a new [class`Gsk`.CairoNode] and appends it to the current
             * render node of `snapshot,` without changing the current node.
             * @param bounds the bounds for the new node
             * @returns a `cairo_t` suitable for drawing the contents of   the newly created render node
             */
            append_cairo(bounds: Graphene.Rect): cairo.Context;
            /**
             * Creates a new render node drawing the `color` into the
             * given `bounds` and appends it to the current render node
             * of `snapshot`.
             *
             * You should try to avoid calling this function if
             * `color` is transparent.
             * @param color the color to draw
             * @param bounds the bounds for the new node
             */
            append_color(color: Gdk.RGBA, bounds: Graphene.Rect): void;
            /**
             * Appends a conic gradient node with the given stops to `snapshot`.
             * @param bounds the rectangle to render the gradient into
             * @param center the center point of the conic gradient
             * @param rotation the clockwise rotation in degrees of the starting angle.   0 means the starting angle is the top.
             * @param stops the color stops defining the gradient
             */
            append_conic_gradient(
                bounds: Graphene.Rect,
                center: Graphene.Point,
                rotation: number,
                stops: Gsk.ColorStop[],
            ): void;
            /**
             * A convenience method to fill a path with a color.
             *
             * See [method`Gtk`.Snapshot.push_fill] if you need
             * to fill a path with more complex content than
             * a color.
             * @param path The path describing the area to fill
             * @param fill_rule The fill rule to use
             * @param color the color to fill the path with
             */
            append_fill(path: Gsk.Path, fill_rule: Gsk.FillRule | null, color: Gdk.RGBA): void;
            /**
             * Appends an inset shadow into the box given by `outline`.
             * @param outline outline of the region surrounded by shadow
             * @param color color of the shadow
             * @param dx horizontal offset of shadow
             * @param dy vertical offset of shadow
             * @param spread how far the shadow spreads towards the inside
             * @param blur_radius how much blur to apply to the shadow
             */
            append_inset_shadow(
                outline: Gsk.RoundedRect,
                color: Gdk.RGBA,
                dx: number,
                dy: number,
                spread: number,
                blur_radius: number,
            ): void;
            /**
             * Creates render nodes for rendering `layout` in the given foregound `color`
             * and appends them to the current node of `snapshot` without changing the
             * current node. The current theme's foreground color for a widget can be
             * obtained with [method`Gtk`.Widget.get_color].
             *
             * Note that if the layout does not produce any visible output, then nodes
             * may not be added to the `snapshot`.
             * @param layout the `PangoLayout` to render
             * @param color the foreground color to render the layout in
             */
            append_layout(layout: Pango.Layout, color: Gdk.RGBA): void;
            /**
             * Appends a linear gradient node with the given stops to `snapshot`.
             * @param bounds the rectangle to render the linear gradient into
             * @param start_point the point at which the linear gradient will begin
             * @param end_point the point at which the linear gradient will finish
             * @param stops the color stops defining the gradient
             */
            append_linear_gradient(
                bounds: Graphene.Rect,
                start_point: Graphene.Point,
                end_point: Graphene.Point,
                stops: Gsk.ColorStop[],
            ): void;
            /**
             * Appends `node` to the current render node of `snapshot,`
             * without changing the current node.
             *
             * If `snapshot` does not have a current node yet, `node`
             * will become the initial node.
             * @param node a `GskRenderNode`
             */
            append_node(node: Gsk.RenderNode): void;
            /**
             * Appends an outset shadow node around the box given by `outline`.
             * @param outline outline of the region surrounded by shadow
             * @param color color of the shadow
             * @param dx horizontal offset of shadow
             * @param dy vertical offset of shadow
             * @param spread how far the shadow spreads towards the outside
             * @param blur_radius how much blur to apply to the shadow
             */
            append_outset_shadow(
                outline: Gsk.RoundedRect,
                color: Gdk.RGBA,
                dx: number,
                dy: number,
                spread: number,
                blur_radius: number,
            ): void;
            /**
             * Appends a radial gradient node with the given stops to `snapshot`.
             * @param bounds the rectangle to render the readial gradient into
             * @param center the center point for the radial gradient
             * @param hradius the horizontal radius
             * @param vradius the vertical radius
             * @param start the start position (on the horizontal axis)
             * @param end the end position (on the horizontal axis)
             * @param stops the color stops defining the gradient
             */
            append_radial_gradient(
                bounds: Graphene.Rect,
                center: Graphene.Point,
                hradius: number,
                vradius: number,
                start: number,
                end: number,
                stops: Gsk.ColorStop[],
            ): void;
            /**
             * Appends a repeating linear gradient node with the given stops to `snapshot`.
             * @param bounds the rectangle to render the linear gradient into
             * @param start_point the point at which the linear gradient will begin
             * @param end_point the point at which the linear gradient will finish
             * @param stops the color stops defining the gradient
             */
            append_repeating_linear_gradient(
                bounds: Graphene.Rect,
                start_point: Graphene.Point,
                end_point: Graphene.Point,
                stops: Gsk.ColorStop[],
            ): void;
            /**
             * Appends a repeating radial gradient node with the given stops to `snapshot`.
             * @param bounds the rectangle to render the readial gradient into
             * @param center the center point for the radial gradient
             * @param hradius the horizontal radius
             * @param vradius the vertical radius
             * @param start the start position (on the horizontal axis)
             * @param end the end position (on the horizontal axis)
             * @param stops the color stops defining the gradient
             */
            append_repeating_radial_gradient(
                bounds: Graphene.Rect,
                center: Graphene.Point,
                hradius: number,
                vradius: number,
                start: number,
                end: number,
                stops: Gsk.ColorStop[],
            ): void;
            /**
             * Creates a new render node drawing the `texture`
             * into the given `bounds` and appends it to the
             * current render node of `snapshot`.
             *
             * In contrast to [method`Gtk`.Snapshot.append_texture],
             * this function provides control about how the filter
             * that is used when scaling.
             * @param texture the texture to render
             * @param filter the filter to use
             * @param bounds the bounds for the new node
             */
            append_scaled_texture(texture: Gdk.Texture, filter: Gsk.ScalingFilter | null, bounds: Graphene.Rect): void;
            /**
             * A convenience method to stroke a path with a color.
             *
             * See [method`Gtk`.Snapshot.push_stroke] if you need
             * to stroke a path with more complex content than
             * a color.
             * @param path The path describing the area to fill
             * @param stroke The stroke attributes
             * @param color the color to fill the path with
             */
            append_stroke(path: Gsk.Path, stroke: Gsk.Stroke, color: Gdk.RGBA): void;
            /**
             * Creates a new render node drawing the `texture`
             * into the given `bounds` and appends it to the
             * current render node of `snapshot`.
             *
             * If the texture needs to be scaled to fill `bounds,`
             * linear filtering is used. See [method`Gtk`.Snapshot.append_scaled_texture]
             * if you need other filtering, such as nearest-neighbour.
             * @param texture the texture to render
             * @param bounds the bounds for the new node
             */
            append_texture(texture: Gdk.Texture, bounds: Graphene.Rect): void;
            /**
             * Removes the top element from the stack of render nodes and
             * adds it to the nearest [class`Gsk`.GLShaderNode] below it.
             *
             * This must be called the same number of times as the number
             * of textures is needed for the shader in
             * [method`Gtk`.Snapshot.push_gl_shader].
             */
            gl_shader_pop_texture(): void;
            /**
             * Applies a perspective projection transform.
             *
             * See [method`Gsk`.Transform.perspective] for a discussion on the details.
             * @param depth distance of the z=0 plane
             */
            perspective(depth: number): void;
            /**
             * Removes the top element from the stack of render nodes,
             * and appends it to the node underneath it.
             */
            pop(): void;
            /**
             * Blends together two images with the given blend mode.
             *
             * Until the first call to [method`Gtk`.Snapshot.pop], the
             * bottom image for the blend operation will be recorded.
             * After that call, the top image to be blended will be
             * recorded until the second call to [method`Gtk`.Snapshot.pop].
             *
             * Calling this function requires two subsequent calls
             * to [method`Gtk`.Snapshot.pop].
             * @param blend_mode blend mode to use
             */
            push_blend(blend_mode: Gsk.BlendMode | null): void;
            /**
             * Blurs an image.
             *
             * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
             * @param radius the blur radius to use. Must be positive
             */
            push_blur(radius: number): void;
            /**
             * Clips an image to a rectangle.
             *
             * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
             * @param bounds the rectangle to clip to
             */
            push_clip(bounds: Graphene.Rect): void;
            /**
             * Modifies the colors of an image by applying an affine transformation
             * in RGB space.
             *
             * In particular, the colors will be transformed by applying
             *
             *     pixel = transpose(color_matrix) * pixel + color_offset
             *
             * for every pixel. The transformation operates on unpremultiplied
             * colors, with color components ordered R, G, B, A.
             *
             * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
             * @param color_matrix the color matrix to use
             * @param color_offset the color offset to use
             */
            push_color_matrix(color_matrix: Graphene.Matrix, color_offset: Graphene.Vec4): void;
            /**
             * Snapshots a cross-fade operation between two images with the
             * given `progress`.
             *
             * Until the first call to [method`Gtk`.Snapshot.pop], the start image
             * will be snapshot. After that call, the end image will be recorded
             * until the second call to [method`Gtk`.Snapshot.pop].
             *
             * Calling this function requires two subsequent calls
             * to [method`Gtk`.Snapshot.pop].
             * @param progress progress between 0.0 and 1.0
             */
            push_cross_fade(progress: number): void;
            /**
             * Fills the area given by `path` and `fill_rule` with an image and discards everything
             * outside of it.
             *
             * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
             *
             * If you want to fill the path with a color, [method`Gtk`.Snapshot.append_fill]
             * may be more convenient.
             * @param path The path describing the area to fill
             * @param fill_rule The fill rule to use
             */
            push_fill(path: Gsk.Path, fill_rule: Gsk.FillRule | null): void;
            /**
             * Push a [class`Gsk`.GLShaderNode].
             *
             * The node uses the given [class`Gsk`.GLShader] and uniform values
             * Additionally this takes a list of `n_children` other nodes
             * which will be passed to the [class`Gsk`.GLShaderNode].
             *
             * The `take_args` argument is a block of data to use for uniform
             * arguments, as per types and offsets defined by the `shader`.
             * Normally this is generated by [method`Gsk`.GLShader.format_args]
             * or [struct`Gsk`.ShaderArgsBuilder].
             *
             * The snapshotter takes ownership of `take_args,` so the caller should
             * not free it after this.
             *
             * If the renderer doesn't support GL shaders, or if there is any
             * problem when compiling the shader, then the node will draw pink.
             * You should use [method`Gsk`.GLShader.compile] to ensure the `shader`
             * will work for the renderer before using it.
             *
             * If the shader requires textures (see [method`Gsk`.GLShader.get_n_textures]),
             * then it is expected that you call [method`Gtk`.Snapshot.gl_shader_pop_texture]
             * the number of times that are required. Each of these calls will generate
             * a node that is added as a child to the `GskGLShaderNode`, which in turn
             * will render these offscreen and pass as a texture to the shader.
             *
             * Once all textures (if any) are pop:ed, you must call the regular
             * [method`Gtk`.Snapshot.pop].
             *
             * If you want to use pre-existing textures as input to the shader rather
             * than rendering new ones, use [method`Gtk`.Snapshot.append_texture] to
             * push a texture node. These will be used directly rather than being
             * re-rendered.
             *
             * For details on how to write shaders, see [class`Gsk`.GLShader].
             * @param shader The code to run
             * @param bounds the rectangle to render into
             * @param take_args Data block with arguments for the shader.
             */
            push_gl_shader(shader: Gsk.GLShader, bounds: Graphene.Rect, take_args: GLib.Bytes | Uint8Array): void;
            /**
             * Until the first call to [method`Gtk`.Snapshot.pop], the
             * mask image for the mask operation will be recorded.
             *
             * After that call, the source image will be recorded until
             * the second call to [method`Gtk`.Snapshot.pop].
             *
             * Calling this function requires 2 subsequent calls to gtk_snapshot_pop().
             * @param mask_mode mask mode to use
             */
            push_mask(mask_mode: Gsk.MaskMode | null): void;
            /**
             * Modifies the opacity of an image.
             *
             * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
             * @param opacity the opacity to use
             */
            push_opacity(opacity: number): void;
            /**
             * Creates a node that repeats the child node.
             *
             * The child is recorded until the next call to [method`Gtk`.Snapshot.pop].
             * @param bounds the bounds within which to repeat
             * @param child_bounds the bounds of the child or %NULL   to use the full size of the collected child node
             */
            push_repeat(bounds: Graphene.Rect, child_bounds?: Graphene.Rect | null): void;
            /**
             * Clips an image to a rounded rectangle.
             *
             * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
             * @param bounds the rounded rectangle to clip to
             */
            push_rounded_clip(bounds: Gsk.RoundedRect): void;
            /**
             * Applies a shadow to an image.
             *
             * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
             * @param shadow the first shadow specification
             */
            push_shadow(shadow: Gsk.Shadow[]): void;
            /**
             * Strokes the given `path` with the attributes given by `stroke` and
             * an image.
             *
             * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
             *
             * Note that the strokes are subject to the same transformation as
             * everything else, so uneven scaling will cause horizontal and vertical
             * strokes to have different widths.
             *
             * If you want to stroke the path with a color, [method`Gtk`.Snapshot.append_stroke]
             * may be more convenient.
             * @param path The path to stroke
             * @param stroke The stroke attributes
             */
            push_stroke(path: Gsk.Path, stroke: Gsk.Stroke): void;
            /**
             * Creates a render node for the CSS background according to `context,`
             * and appends it to the current node of `snapshot,` without changing
             * the current node.
             * @param context the style context that defines the background
             * @param x X origin of the rectangle
             * @param y Y origin of the rectangle
             * @param width rectangle width
             * @param height rectangle height
             */
            render_background(context: StyleContext, x: number, y: number, width: number, height: number): void;
            /**
             * Creates a render node for the focus outline according to `context,`
             * and appends it to the current node of `snapshot,` without changing
             * the current node.
             * @param context the style context that defines the focus ring
             * @param x X origin of the rectangle
             * @param y Y origin of the rectangle
             * @param width rectangle width
             * @param height rectangle height
             */
            render_focus(context: StyleContext, x: number, y: number, width: number, height: number): void;
            /**
             * Creates a render node for the CSS border according to `context,`
             * and appends it to the current node of `snapshot,` without changing
             * the current node.
             * @param context the style context that defines the frame
             * @param x X origin of the rectangle
             * @param y Y origin of the rectangle
             * @param width rectangle width
             * @param height rectangle height
             */
            render_frame(context: StyleContext, x: number, y: number, width: number, height: number): void;
            /**
             * Draws a text caret using `snapshot` at the specified index of `layout`.
             * @param context a `GtkStyleContext`
             * @param x X origin
             * @param y Y origin
             * @param layout the `PangoLayout` of the text
             * @param index the index in the `PangoLayout`
             * @param direction the `PangoDirection` of the text
             */
            render_insertion_cursor(
                context: StyleContext,
                x: number,
                y: number,
                layout: Pango.Layout,
                index: number,
                direction: Pango.Direction | null,
            ): void;
            /**
             * Creates a render node for rendering `layout` according to the style
             * information in `context,` and appends it to the current node of `snapshot,`
             * without changing the current node.
             * @param context the style context that defines the text
             * @param x X origin of the rectangle
             * @param y Y origin of the rectangle
             * @param layout the `PangoLayout` to render
             */
            render_layout(context: StyleContext, x: number, y: number, layout: Pango.Layout): void;
            /**
             * Restores `snapshot` to the state saved by a preceding call to
             * [method`Snapshot`.save] and removes that state from the stack of
             * saved states.
             */
            restore(): void;
            /**
             * Rotates `@`snapshot's coordinate system by `angle` degrees in 2D space -
             * or in 3D speak, rotates around the Z axis. The rotation happens around
             * the origin point of (0, 0) in the `snapshot'`s current coordinate system.
             *
             * To rotate around axes other than the Z axis, use [method`Gsk`.Transform.rotate_3d].
             * @param angle the rotation angle, in degrees (clockwise)
             */
            rotate(angle: number): void;
            /**
             * Rotates `snapshot'`s coordinate system by `angle` degrees around `axis`.
             *
             * For a rotation in 2D space, use [method`Gsk`.Transform.rotate].
             * @param angle the rotation angle, in degrees (clockwise)
             * @param axis The rotation axis
             */
            rotate_3d(angle: number, axis: Graphene.Vec3): void;
            /**
             * Makes a copy of the current state of `snapshot` and saves it
             * on an internal stack.
             *
             * When [method`Gtk`.Snapshot.restore] is called, `snapshot` will
             * be restored to the saved state.
             *
             * Multiple calls to [method`Gtk`.Snapshot.save] and [method`Gtk`.Snapshot.restore]
             * can be nested; each call to `gtk_snapshot_restore()` restores the state from
             * the matching paired `gtk_snapshot_save()`.
             *
             * It is necessary to clear all saved states with corresponding
             * calls to `gtk_snapshot_restore()`.
             */
            save(): void;
            /**
             * Scales `snapshot'`s coordinate system in 2-dimensional space by
             * the given factors.
             *
             * Use [method`Gtk`.Snapshot.scale_3d] to scale in all 3 dimensions.
             * @param factor_x scaling factor on the X axis
             * @param factor_y scaling factor on the Y axis
             */
            scale(factor_x: number, factor_y: number): void;
            /**
             * Scales `snapshot'`s coordinate system by the given factors.
             * @param factor_x scaling factor on the X axis
             * @param factor_y scaling factor on the Y axis
             * @param factor_z scaling factor on the Z axis
             */
            scale_3d(factor_x: number, factor_y: number, factor_z: number): void;
            /**
             * Returns the render node that was constructed
             * by `snapshot`.
             *
             * Note that this function may return %NULL if nothing has been
             * added to the snapshot or if its content does not produce pixels
             * to be rendered.
             *
             * After calling this function, it is no longer possible to
             * add more nodes to `snapshot`. The only function that should
             * be called after this is [method`GObject`.Object.unref].
             * @returns the constructed `GskRenderNode` or   %NULL if there are no nodes to render.
             */
            to_node(): Gsk.RenderNode | null;
            /**
             * Returns a paintable encapsulating the render node
             * that was constructed by `snapshot`.
             *
             * After calling this function, it is no longer possible to
             * add more nodes to `snapshot`. The only function that should
             * be called after this is [method`GObject`.Object.unref].
             * @param size The size of the resulting paintable   or %NULL to use the bounds of the snapshot
             * @returns a new `GdkPaintable`
             */
            to_paintable(size?: Graphene.Size | null): Gdk.Paintable | null;
            /**
             * Transforms `snapshot'`s coordinate system with the given `transform`.
             * @param transform the transform to apply
             */
            transform(transform?: Gsk.Transform | null): void;
            /**
             * Transforms `snapshot'`s coordinate system with the given `matrix`.
             * @param matrix the matrix to multiply the transform with
             */
            transform_matrix(matrix: Graphene.Matrix): void;
            /**
             * Translates `snapshot'`s coordinate system by `point` in 2-dimensional space.
             * @param point the point to translate the snapshot by
             */
            translate(point: Graphene.Point): void;
            /**
             * Translates `snapshot'`s coordinate system by `point`.
             * @param point the point to translate the snapshot by
             */
            translate_3d(point: Graphene.Point3D): void;
        }

        namespace SortListModel {
            // Constructor properties interface

            interface ConstructorProps<A extends GObject.Object = GObject.Object>
                extends GObject.Object.ConstructorProps,
                    Gio.ListModel.ConstructorProps,
                    SectionModel.ConstructorProps {
                incremental: boolean;
                item_type: GObject.GType;
                itemType: GObject.GType;
                model: Gio.ListModel;
                n_items: number;
                nItems: number;
                pending: number;
                section_sorter: Sorter;
                sectionSorter: Sorter;
                sorter: Sorter;
            }
        }

        /**
         * A `GListModel` that sorts the elements of an underlying model
         * according to a `GtkSorter`.
         *
         * The model is a stable sort. If two items compare equal according
         * to the sorter, the one that appears first in the original model will
         * also appear first after sorting.
         * Note that if you change the sorter, the previous order will have no
         * influence on the new order. If you want that, consider using a
         * `GtkMultiSorter` and appending the previous sorter to it.
         *
         * The model can be set up to do incremental sorting, so that
         * sorting long lists doesn't block the UI. See
         * [method`Gtk`.SortListModel.set_incremental] for details.
         *
         * `GtkSortListModel` is a generic model and because of that it
         * cannot take advantage of any external knowledge when sorting.
         * If you run into performance issues with `GtkSortListModel`,
         * it is strongly recommended that you write your own sorting list
         * model.
         *
         * `GtkSortListModel` allows sorting the items into sections. It
         * implements `GtkSectionModel` and when [property`Gtk`.SortListModel:section-sorter]
         * is set, it will sort all items with that sorter and items comparing
         * equal with it will be put into the same section.
         * The [property`Gtk`.SortListModel:sorter] will then be used to sort items
         * inside their sections.
         */
        class SortListModel<A extends GObject.Object = GObject.Object>
            extends GObject.Object
            implements Gio.ListModel<A>, SectionModel
        {
            static $gtype: GObject.GType<SortListModel>;

            // Properties

            /**
             * If the model should sort items incrementally.
             */
            get incremental(): boolean;
            set incremental(val: boolean);
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get item_type(): GObject.GType;
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get itemType(): GObject.GType;
            /**
             * The model being sorted.
             */
            get model(): Gio.ListModel;
            set model(val: Gio.ListModel);
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get n_items(): number;
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get nItems(): number;
            /**
             * Estimate of unsorted items remaining.
             */
            get pending(): number;
            /**
             * The section sorter for this model, if one is set.
             */
            get section_sorter(): Sorter;
            set section_sorter(val: Sorter);
            /**
             * The section sorter for this model, if one is set.
             */
            get sectionSorter(): Sorter;
            set sectionSorter(val: Sorter);
            /**
             * The sorter for this model.
             */
            get sorter(): Sorter;
            set sorter(val: Sorter);

            // Constructors

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

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

            static ['new'](model?: Gio.ListModel | null, sorter?: Sorter | null): SortListModel;

            // Methods

            /**
             * Returns whether incremental sorting is enabled.
             *
             * See [method`Gtk`.SortListModel.set_incremental].
             * @returns %TRUE if incremental sorting is enabled
             */
            get_incremental(): boolean;
            /**
             * Gets the model currently sorted or %NULL if none.
             * @returns The model that gets sorted
             */
            get_model(): Gio.ListModel | null;
            /**
             * Estimates progress of an ongoing sorting operation.
             *
             * The estimate is the number of items that would still need to be
             * sorted to finish the sorting operation if this was a linear
             * algorithm. So this number is not related to how many items are
             * already correctly sorted.
             *
             * If you want to estimate the progress, you can use code like this:
             * ```c
             * pending = gtk_sort_list_model_get_pending (self);
             * model = gtk_sort_list_model_get_model (self);
             * progress = 1.0 - pending / (double) MAX (1, g_list_model_get_n_items (model));
             * ```
             *
             * If no sort operation is ongoing - in particular when
             * [property`Gtk`.SortListModel:incremental] is %FALSE - this
             * function returns 0.
             * @returns a progress estimate of remaining items to sort
             */
            get_pending(): number;
            /**
             * Gets the section sorter that is used to sort items of `self` into
             * sections.
             * @returns the sorter of #self
             */
            get_section_sorter(): Sorter | null;
            /**
             * Gets the sorter that is used to sort `self`.
             * @returns the sorter of #self
             */
            get_sorter(): Sorter | null;
            /**
             * Sets the sort model to do an incremental sort.
             *
             * When incremental sorting is enabled, the `GtkSortListModel` will not do
             * a complete sort immediately, but will instead queue an idle handler that
             * incrementally sorts the items towards their correct position. This of
             * course means that items do not instantly appear in the right place. It
             * also means that the total sorting time is a lot slower.
             *
             * When your filter blocks the UI while sorting, you might consider
             * turning this on. Depending on your model and sorters, this may become
             * interesting around 10,000 to 100,000 items.
             *
             * By default, incremental sorting is disabled.
             *
             * See [method`Gtk`.SortListModel.get_pending] for progress information
             * about an ongoing incremental sorting operation.
             * @param incremental %TRUE to sort incrementally
             */
            set_incremental(incremental: boolean): void;
            /**
             * Sets the model to be sorted.
             *
             * The `model'`s item type must conform to the item type of `self`.
             * @param model The model to be sorted
             */
            set_model(model?: Gio.ListModel | null): void;
            /**
             * Sets a new section sorter on `self`.
             * @param sorter the `GtkSorter` to sort @model with
             */
            set_section_sorter(sorter?: Sorter | null): void;
            /**
             * Sets a new sorter on `self`.
             * @param sorter the `GtkSorter` to sort @model with
             */
            set_sorter(sorter?: Sorter | null): void;

            // Inherited methods
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             * @returns the #GType of the items contained in @list.
             */
            get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             * @returns the number of items in @list.
             */
            get_n_items(): number;
            /**
             * Get the item at `position`.
             *
             * If `position` is greater than the number of items in `list,` %NULL is
             * returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.
             *
             * This function is meant to be used by language bindings in place
             * of g_list_model_get_item().
             *
             * See also: g_list_model_get_n_items()
             * @param position the position of the item to fetch
             * @returns the object at @position.
             */
            get_item(position: number): A | null;
            /**
             * Emits the #GListModel::items-changed signal on `list`.
             *
             * This function should only be called by classes implementing
             * #GListModel. It has to be called after the internal representation
             * of `list` has been updated, because handlers connected to this signal
             * might query the new state of the list.
             *
             * Implementations must only make changes to the model (as visible to
             * its consumer) in places that will not cause problems for that
             * consumer.  For models that are driven directly by a write API (such
             * as #GListStore), changes can be reported in response to uses of that
             * API.  For models that represent remote data, changes should only be
             * made from a fresh mainloop dispatch.  It is particularly not
             * permitted to make changes in response to a call to the #GListModel
             * consumer API.
             *
             * Stated another way: in general, it is assumed that code making a
             * series of accesses to the model via the API, without returning to the
             * mainloop, and without calling other code, will continue to view the
             * same contents of the model.
             * @param position the position at which @list changed
             * @param removed the number of items removed
             * @param added the number of items added
             */
            items_changed(position: number, removed: number, added: number): void;
            /**
             * Get the item at `position`. If `position` is greater than the number of
             * items in `list,` %NULL is returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.  See g_list_model_get_n_items().
             *
             * The same #GObject instance may not appear more than once in a #GListModel.
             * @param position the position of the item to fetch
             */
            vfunc_get_item(position: number): A | null;
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             */
            vfunc_get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             */
            vfunc_get_n_items(): number;
            /**
             * Query the section that covers the given position. The number of
             * items in the section can be computed by `out_end - out_start`.
             *
             * If the position is larger than the number of items, a single
             * range from n_items to G_MAXUINT will be returned.
             * @param position the position of the item to query
             */
            get_section(position: number): [number, number];
            /**
             * This function emits the [signal`Gtk`.SectionModel::sections-changed]
             * signal to notify about changes to sections.
             *
             * It must cover all positions that used to be a section start or that
             * are now a section start. It does not have to cover all positions for
             * which the section has changed.
             *
             * The [signal`Gio`.ListModel::items-changed] implies the effect of the
             * [signal`Gtk`.SectionModel::sections-changed] signal for all the items
             * it covers.
             *
             * It is recommended that when changes to the items cause section changes
             * in a larger range, that the larger range is included in the emission
             * of the [signal`Gio`.ListModel::items-changed] instead of emitting
             * two signals.
             * @param position the first changed item
             * @param n_items the number of changed items
             */
            sections_changed(position: number, n_items: number): void;
            /**
             * Query the section that covers the given position. The number of
             * items in the section can be computed by `out_end - out_start`.
             *
             * If the position is larger than the number of items, a single
             * range from n_items to G_MAXUINT will be returned.
             * @param position the position of the item to query
             */
            vfunc_get_section(position: number): [number, number];
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Sorter {
            // Signal callback interfaces

            interface Changed {
                (change: SorterChange): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * `GtkSorter` is an object to describe sorting criteria.
         *
         * Its primary user is [class`Gtk`.SortListModel]
         *
         * The model will use a sorter to determine the order in which
         * its items should appear by calling [method`Gtk`.Sorter.compare]
         * for pairs of items.
         *
         * Sorters may change their sorting behavior through their lifetime.
         * In that case, they will emit the [signal`Gtk`.Sorter::changed] signal
         * to notify that the sort order is no longer valid and should be updated
         * by calling gtk_sorter_compare() again.
         *
         * GTK provides various pre-made sorter implementations for common sorting
         * operations. [class`Gtk`.ColumnView] has built-in support for sorting lists
         * via the [property`Gtk`.ColumnViewColumn:sorter] property, where the user can
         * change the sorting by clicking on list headers.
         *
         * Of course, in particular for large lists, it is also possible to subclass
         * `GtkSorter` and provide one's own sorter.
         */
        class Sorter extends GObject.Object {
            static $gtype: GObject.GType<Sorter>;

            // Constructors

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

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

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'changed', callback: (_source: this, change: SorterChange) => void): number;
            connect_after(signal: 'changed', callback: (_source: this, change: SorterChange) => void): number;
            emit(signal: 'changed', change: SorterChange): void;

            // Virtual methods

            /**
             * Compares two given items according to the sort order implemented
             * by the sorter.
             *
             * Sorters implement a partial order:
             *
             * * It is reflexive, ie a = a
             * * It is antisymmetric, ie if a < b and b < a, then a = b
             * * It is transitive, ie given any 3 items with a ≤ b and b ≤ c,
             *   then a ≤ c
             *
             * The sorter may signal it conforms to additional constraints
             * via the return value of [method`Gtk`.Sorter.get_order].
             * @param item1 first item to compare
             * @param item2 second item to compare
             */
            vfunc_compare(item1?: GObject.Object | null, item2?: GObject.Object | null): Ordering;
            /**
             * Gets the order that `self` conforms to.
             *
             * See [enum`Gtk`.SorterOrder] for details
             * of the possible return values.
             *
             * This function is intended to allow optimizations.
             */
            vfunc_get_order(): SorterOrder;

            // Methods

            /**
             * Notifies all users of the sorter that it has changed.
             *
             * This emits the [signal`Gtk`.Sorter::changed] signal. Users
             * of the sorter should then update the sort order via
             * [method`Gtk`.Sorter.compare].
             *
             * Depending on the `change` parameter, it may be possible to
             * update the sort order without a full resorting. Refer to
             * the [enum`Gtk`.SorterChange] documentation for details.
             *
             * This function is intended for implementers of `GtkSorter`
             * subclasses and should not be called from other functions.
             * @param change How the sorter changed
             */
            changed(change: SorterChange | null): void;
            /**
             * Compares two given items according to the sort order implemented
             * by the sorter.
             *
             * Sorters implement a partial order:
             *
             * * It is reflexive, ie a = a
             * * It is antisymmetric, ie if a < b and b < a, then a = b
             * * It is transitive, ie given any 3 items with a ≤ b and b ≤ c,
             *   then a ≤ c
             *
             * The sorter may signal it conforms to additional constraints
             * via the return value of [method`Gtk`.Sorter.get_order].
             * @param item1 first item to compare
             * @param item2 second item to compare
             * @returns %GTK_ORDERING_EQUAL if @item1 == @item2,   %GTK_ORDERING_SMALLER if @item1 < @item2,   %GTK_ORDERING_LARGER if @item1 > @item2
             */
            compare(item1: GObject.Object, item2: GObject.Object): Ordering;
            /**
             * Gets the order that `self` conforms to.
             *
             * See [enum`Gtk`.SorterOrder] for details
             * of the possible return values.
             *
             * This function is intended to allow optimizations.
             * @returns The order
             */
            get_order(): SorterOrder;
        }

        namespace SpinButton {
            // Signal callback interfaces

            interface Activate {
                (): void;
            }

            interface ChangeValue {
                (scroll: ScrollType): void;
            }

            interface Input {
                (new_value: number): number;
            }

            interface Output {
                (): boolean;
            }

            interface ValueChanged {
                (): void;
            }

            interface Wrapped {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    AccessibleRange.ConstructorProps,
                    Buildable.ConstructorProps,
                    CellEditable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Editable.ConstructorProps,
                    Orientable.ConstructorProps {
                activates_default: boolean;
                activatesDefault: boolean;
                adjustment: Adjustment;
                climb_rate: number;
                climbRate: number;
                digits: number;
                numeric: boolean;
                snap_to_ticks: boolean;
                snapToTicks: boolean;
                update_policy: SpinButtonUpdatePolicy;
                updatePolicy: SpinButtonUpdatePolicy;
                value: number;
                wrap: boolean;
            }
        }

        /**
         * A `GtkSpinButton` is an ideal way to allow the user to set the
         * value of some attribute.
         *
         * ![An example GtkSpinButton](spinbutton.png)
         *
         * Rather than having to directly type a number into a `GtkEntry`,
         * `GtkSpinButton` allows the user to click on one of two arrows
         * to increment or decrement the displayed value. A value can still be
         * typed in, with the bonus that it can be checked to ensure it is in a
         * given range.
         *
         * The main properties of a `GtkSpinButton` are through an adjustment.
         * See the [class`Gtk`.Adjustment] documentation for more details about
         * an adjustment's properties.
         *
         * Note that `GtkSpinButton` will by default make its entry large enough
         * to accommodate the lower and upper bounds of the adjustment. If this
         * is not desired, the automatic sizing can be turned off by explicitly
         * setting [property`Gtk`.Editable:width-chars] to a value != -1.
         *
         * ## Using a GtkSpinButton to get an integer
         *
         * ```c
         * // Provides a function to retrieve an integer value from a GtkSpinButton
         * // and creates a spin button to model percentage values.
         *
         * int
         * grab_int_value (GtkSpinButton *button,
         *                 gpointer       user_data)
         * {
         *   return gtk_spin_button_get_value_as_int (button);
         * }
         *
         * void
         * create_integer_spin_button (void)
         * {
         *
         *   GtkWidget *window, *button;
         *   GtkAdjustment *adjustment;
         *
         *   adjustment = gtk_adjustment_new (50.0, 0.0, 100.0, 1.0, 5.0, 0.0);
         *
         *   window = gtk_window_new ();
         *
         *   // creates the spinbutton, with no decimal places
         *   button = gtk_spin_button_new (adjustment, 1.0, 0);
         *   gtk_window_set_child (GTK_WINDOW (window), button);
         *
         *   gtk_window_present (GTK_WINDOW (window));
         * }
         * ```
         *
         * ## Using a GtkSpinButton to get a floating point value
         *
         * ```c
         * // Provides a function to retrieve a floating point value from a
         * // GtkSpinButton, and creates a high precision spin button.
         *
         * float
         * grab_float_value (GtkSpinButton *button,
         *                   gpointer       user_data)
         * {
         *   return gtk_spin_button_get_value (button);
         * }
         *
         * void
         * create_floating_spin_button (void)
         * {
         *   GtkWidget *window, *button;
         *   GtkAdjustment *adjustment;
         *
         *   adjustment = gtk_adjustment_new (2.500, 0.0, 5.0, 0.001, 0.1, 0.0);
         *
         *   window = gtk_window_new ();
         *
         *   // creates the spinbutton, with three decimal places
         *   button = gtk_spin_button_new (adjustment, 0.001, 3);
         *   gtk_window_set_child (GTK_WINDOW (window), button);
         *
         *   gtk_window_present (GTK_WINDOW (window));
         * }
         * ```
         *
         * # Shortcuts and Gestures
         *
         * The following signals have default keybindings:
         *
         * - [signal`Gtk`.SpinButton::change-value]
         *
         * # CSS nodes
         *
         * ```
         * spinbutton.horizontal
         * ├── text
         * │    ├── undershoot.left
         * │    ╰── undershoot.right
         * ├── button.down
         * ╰── button.up
         * ```
         *
         * ```
         * spinbutton.vertical
         * ├── button.up
         * ├── text
         * │    ├── undershoot.left
         * │    ╰── undershoot.right
         * ╰── button.down
         * ```
         *
         * `GtkSpinButton`s main CSS node has the name spinbutton. It creates subnodes
         * for the entry and the two buttons, with these names. The button nodes have
         * the style classes .up and .down. The `GtkText` subnodes (if present) are put
         * below the text node. The orientation of the spin button is reflected in
         * the .vertical or .horizontal style class on the main node.
         *
         * # Accessibility
         *
         * `GtkSpinButton` uses the %GTK_ACCESSIBLE_ROLE_SPIN_BUTTON role.
         */
        class SpinButton
            extends Widget
            implements Accessible, AccessibleRange, Buildable, CellEditable, ConstraintTarget, Editable, Orientable
        {
            static $gtype: GObject.GType<SpinButton>;

            // Properties

            /**
             * Whether to activate the default widget when the spin button is activated.
             *
             * See [signal`Gtk`.SpinButton::activate] for what counts as activation.
             */
            get activates_default(): boolean;
            set activates_default(val: boolean);
            /**
             * Whether to activate the default widget when the spin button is activated.
             *
             * See [signal`Gtk`.SpinButton::activate] for what counts as activation.
             */
            get activatesDefault(): boolean;
            set activatesDefault(val: boolean);
            /**
             * The adjustment that holds the value of the spin button.
             */
            get adjustment(): Adjustment;
            set adjustment(val: Adjustment);
            /**
             * The acceleration rate when you hold down a button or key.
             */
            get climb_rate(): number;
            set climb_rate(val: number);
            /**
             * The acceleration rate when you hold down a button or key.
             */
            get climbRate(): number;
            set climbRate(val: number);
            /**
             * The number of decimal places to display.
             */
            get digits(): number;
            set digits(val: number);
            /**
             * Whether non-numeric characters should be ignored.
             */
            get numeric(): boolean;
            set numeric(val: boolean);
            /**
             * Whether erroneous values are automatically changed to the spin buttons
             * nearest step increment.
             */
            get snap_to_ticks(): boolean;
            set snap_to_ticks(val: boolean);
            /**
             * Whether erroneous values are automatically changed to the spin buttons
             * nearest step increment.
             */
            get snapToTicks(): boolean;
            set snapToTicks(val: boolean);
            /**
             * Whether the spin button should update always, or only when the value
             * is acceptable.
             */
            get update_policy(): SpinButtonUpdatePolicy;
            set update_policy(val: SpinButtonUpdatePolicy);
            /**
             * Whether the spin button should update always, or only when the value
             * is acceptable.
             */
            get updatePolicy(): SpinButtonUpdatePolicy;
            set updatePolicy(val: SpinButtonUpdatePolicy);
            /**
             * The current value.
             */
            get value(): number;
            set value(val: number);
            /**
             * Whether a spin button should wrap upon reaching its limits.
             */
            get wrap(): boolean;
            set wrap(val: boolean);

            // Constructors

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

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

            static ['new'](adjustment: Adjustment | null, climb_rate: number, digits: number): SpinButton;

            static new_with_range(min: number, max: number, step: number): SpinButton;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate', callback: (_source: this) => void): number;
            connect_after(signal: 'activate', callback: (_source: this) => void): number;
            emit(signal: 'activate'): void;
            connect(signal: 'change-value', callback: (_source: this, scroll: ScrollType) => void): number;
            connect_after(signal: 'change-value', callback: (_source: this, scroll: ScrollType) => void): number;
            emit(signal: 'change-value', scroll: ScrollType): void;
            connect(signal: 'input', callback: (_source: this, new_value: number) => number): number;
            connect_after(signal: 'input', callback: (_source: this, new_value: number) => number): number;
            emit(signal: 'input', new_value: number): void;
            connect(signal: 'output', callback: (_source: this) => boolean): number;
            connect_after(signal: 'output', callback: (_source: this) => boolean): number;
            emit(signal: 'output'): void;
            connect(signal: 'value-changed', callback: (_source: this) => void): number;
            connect_after(signal: 'value-changed', callback: (_source: this) => void): number;
            emit(signal: 'value-changed'): void;
            connect(signal: 'wrapped', callback: (_source: this) => void): number;
            connect_after(signal: 'wrapped', callback: (_source: this) => void): number;
            emit(signal: 'wrapped'): void;

            // Methods

            /**
             * Changes the properties of an existing spin button.
             *
             * The adjustment, climb rate, and number of decimal places
             * are updated accordingly.
             * @param adjustment a `GtkAdjustment` to replace the spin button’s   existing adjustment, or %NULL to leave its current adjustment unchanged
             * @param climb_rate the new climb rate
             * @param digits the number of decimal places to display in the spin button
             */
            configure(adjustment: Adjustment | null, climb_rate: number, digits: number): void;
            /**
             * Retrieves the value set by [method`Gtk`.SpinButton.set_activates_default].
             * @returns %TRUE if the spin button will activate the default widget
             */
            get_activates_default(): boolean;
            /**
             * Get the adjustment associated with a `GtkSpinButton`.
             * @returns the `GtkAdjustment` of @spin_button
             */
            get_adjustment(): Adjustment;
            /**
             * Returns the acceleration rate for repeated changes.
             * @returns the acceleration rate
             */
            get_climb_rate(): number;
            /**
             * Fetches the precision of `spin_button`.
             * @returns the current precision
             */
            get_digits(): number;
            /**
             * Gets the current step and page the increments
             * used by `spin_button`.
             *
             * See [method`Gtk`.SpinButton.set_increments].
             */
            get_increments(): [number, number];
            /**
             * Returns whether non-numeric text can be typed into the spin button.
             * @returns %TRUE if only numeric text can be entered
             */
            get_numeric(): boolean;
            /**
             * Gets the range allowed for `spin_button`.
             *
             * See [method`Gtk`.SpinButton.set_range].
             */
            get_range(): [number, number];
            /**
             * Returns whether the values are corrected to the nearest step.
             * @returns %TRUE if values are snapped to the nearest step
             */
            get_snap_to_ticks(): boolean;
            /**
             * Gets the update behavior of a spin button.
             *
             * See [method`Gtk`.SpinButton.set_update_policy].
             * @returns the current update policy
             */
            get_update_policy(): SpinButtonUpdatePolicy;
            /**
             * Get the value in the `spin_button`.
             * @returns the value of @spin_button
             */
            get_value(): number;
            /**
             * Get the value `spin_button` represented as an integer.
             * @returns the value of @spin_button
             */
            get_value_as_int(): number;
            /**
             * Returns whether the spin button’s value wraps around to the
             * opposite limit when the upper or lower limit of the range is
             * exceeded.
             * @returns %TRUE if the spin button wraps around
             */
            get_wrap(): boolean;
            /**
             * Sets whether activating the spin button will activate the default
             * widget for the window containing the spin button.
             *
             * See [signal`Gtk`.SpinButton::activate] for what counts as activation.
             * @param activates_default %TRUE to activate window’s default widget on activation
             */
            set_activates_default(activates_default: boolean): void;
            /**
             * Replaces the `GtkAdjustment` associated with `spin_button`.
             * @param adjustment a `GtkAdjustment` to replace the existing adjustment
             */
            set_adjustment(adjustment: Adjustment): void;
            /**
             * Sets the acceleration rate for repeated changes when you
             * hold down a button or key.
             * @param climb_rate the rate of acceleration, must be >= 0
             */
            set_climb_rate(climb_rate: number): void;
            /**
             * Set the precision to be displayed by `spin_button`.
             *
             * Up to 20 digit precision is allowed.
             * @param digits the number of digits after the decimal point to be   displayed for the spin button’s value
             */
            set_digits(digits: number): void;
            /**
             * Sets the step and page increments for spin_button.
             *
             * This affects how quickly the value changes when
             * the spin button’s arrows are activated.
             * @param step increment applied for a button 1 press.
             * @param page increment applied for a button 2 press.
             */
            set_increments(step: number, page: number): void;
            /**
             * Sets the flag that determines if non-numeric text can be typed
             * into the spin button.
             * @param numeric flag indicating if only numeric entry is allowed
             */
            set_numeric(numeric: boolean): void;
            /**
             * Sets the minimum and maximum allowable values for `spin_button`.
             *
             * If the current value is outside this range, it will be adjusted
             * to fit within the range, otherwise it will remain unchanged.
             * @param min minimum allowable value
             * @param max maximum allowable value
             */
            set_range(min: number, max: number): void;
            /**
             * Sets the policy as to whether values are corrected to the
             * nearest step increment when a spin button is activated after
             * providing an invalid value.
             * @param snap_to_ticks a flag indicating if invalid values should be corrected
             */
            set_snap_to_ticks(snap_to_ticks: boolean): void;
            /**
             * Sets the update behavior of a spin button.
             *
             * This determines whether the spin button is always
             * updated or only when a valid value is set.
             * @param policy a `GtkSpinButtonUpdatePolicy` value
             */
            set_update_policy(policy: SpinButtonUpdatePolicy | null): void;
            /**
             * Sets the value of `spin_button`.
             * @param value the new value
             */
            set_value(value: number): void;
            /**
             * Sets the flag that determines if a spin button value wraps
             * around to the opposite limit when the upper or lower limit
             * of the range is exceeded.
             * @param wrap a flag indicating if wrapping behavior is performed
             */
            set_wrap(wrap: boolean): void;
            /**
             * Increment or decrement a spin button’s value in a specified
             * direction by a specified amount.
             * @param direction a `GtkSpinType` indicating the direction to spin
             * @param increment step increment to apply in the specified direction
             */
            spin(direction: SpinType | null, increment: number): void;
            /**
             * Manually force an update of the spin button.
             */
            update(): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * Indicates whether editing on the cell has been canceled.
             */
            get editing_canceled(): boolean;
            set editing_canceled(val: boolean);
            /**
             * Indicates whether editing on the cell has been canceled.
             */
            get editingCanceled(): boolean;
            set editingCanceled(val: boolean);
            /**
             * The current position of the insertion cursor in chars.
             */
            get cursor_position(): number;
            /**
             * The current position of the insertion cursor in chars.
             */
            get cursorPosition(): number;
            /**
             * Whether the entry contents can be edited.
             */
            get editable(): boolean;
            set editable(val: boolean);
            /**
             * If undo/redo should be enabled for the editable.
             */
            get enable_undo(): boolean;
            set enable_undo(val: boolean);
            /**
             * If undo/redo should be enabled for the editable.
             */
            get enableUndo(): boolean;
            set enableUndo(val: boolean);
            /**
             * The desired maximum width of the entry, in characters.
             */
            get max_width_chars(): number;
            set max_width_chars(val: number);
            /**
             * The desired maximum width of the entry, in characters.
             */
            get maxWidthChars(): number;
            set maxWidthChars(val: number);
            /**
             * The position of the opposite end of the selection from the cursor in chars.
             */
            get selection_bound(): number;
            /**
             * The position of the opposite end of the selection from the cursor in chars.
             */
            get selectionBound(): number;
            /**
             * The contents of the entry.
             */
            get text(): string;
            set text(val: string);
            /**
             * Number of characters to leave space for in the entry.
             */
            get width_chars(): number;
            set width_chars(val: number);
            /**
             * Number of characters to leave space for in the entry.
             */
            get widthChars(): number;
            set widthChars(val: number);
            /**
             * The horizontal alignment, from 0 (left) to 1 (right).
             *
             * Reversed for RTL layouts.
             */
            get xalign(): number;
            set xalign(val: number);
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Sets the current value of the accessible range.
             *
             * This operation should behave similarly as if the user performed the
             * action.
             * @param value the value to set
             */
            vfunc_set_current_value(value: number): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Emits the `GtkCellEditable::editing-done` signal.
             */
            editing_done(): void;
            /**
             * Emits the `GtkCellEditable::remove-widget` signal.
             */
            remove_widget(): void;
            /**
             * Begins editing on a `cell_editable`.
             *
             * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
             * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
             *
             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
             * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
             *
             * Note that the `cell_editable` is created on-demand for the current edit; its
             * lifetime is temporary and does not persist across other edits and/or cells.
             * @param event The `GdkEvent` that began the editing process, or   %NULL if editing was initiated programmatically
             */
            start_editing(event?: Gdk.Event | null): void;
            /**
             * Emits the `GtkCellEditable::editing-done` signal.
             */
            vfunc_editing_done(): void;
            /**
             * Emits the `GtkCellEditable::remove-widget` signal.
             */
            vfunc_remove_widget(): void;
            /**
             * Begins editing on a `cell_editable`.
             *
             * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
             * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
             *
             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
             * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
             *
             * Note that the `cell_editable` is created on-demand for the current edit; its
             * lifetime is temporary and does not persist across other edits and/or cells.
             * @param event The `GdkEvent` that began the editing process, or   %NULL if editing was initiated programmatically
             */
            vfunc_start_editing(event?: Gdk.Event | null): void;
            /**
             * Retrieves the accessible platform state from the editable delegate.
             *
             * This is an helper function to retrieve the accessible state for
             * `GtkEditable` interface implementations using a delegate pattern.
             *
             * You should call this function in your editable widget implementation
             * of the [vfunc`Gtk`.Accessible.get_platform_state] virtual function, for
             * instance:
             *
             * ```c
             * static void
             * accessible_interface_init (GtkAccessibleInterface *iface)
             * {
             *   iface->get_platform_state = your_editable_get_accessible_platform_state;
             * }
             *
             * static gboolean
             * your_editable_get_accessible_platform_state (GtkAccessible *accessible,
             *                                              GtkAccessiblePlatformState state)
             * {
             *   return gtk_editable_delegate_get_accessible_platform_state (GTK_EDITABLE (accessible), state);
             * }
             * ```
             *
             * Note that the widget which is the delegate *must* be a direct child of
             * this widget, otherwise your implementation of [vfunc`Gtk`.Accessible.get_platform_state]
             * might not even be called, as the platform change will originate from
             * the parent of the delegate, and, as a result, will not work properly.
             *
             * So, if you can't ensure the direct child condition, you should give the
             * delegate the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role, or you can
             * change your tree to allow this function to work.
             * @param state what kind of accessible state to retrieve
             * @returns the accessible platform state of the delegate
             */
            delegate_get_accessible_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Deletes the currently selected text of the editable.
             *
             * This call doesn’t do anything if there is no selected text.
             */
            delete_selection(): void;
            /**
             * Deletes a sequence of characters.
             *
             * The characters that are deleted are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters deleted are those from `start_pos` to
             * the end of the text.
             *
             * Note that the positions are specified in characters, not bytes.
             * @param start_pos start position
             * @param end_pos end position
             */
            delete_text(start_pos: number, end_pos: number): void;
            /**
             * Undoes the setup done by [method`Gtk`.Editable.init_delegate].
             *
             * This is a helper function that should be called from dispose,
             * before removing the delegate object.
             */
            finish_delegate(): void;
            /**
             * Gets the alignment of the editable.
             * @returns the alignment
             */
            get_alignment(): number;
            /**
             * Retrieves a sequence of characters.
             *
             * The characters that are retrieved are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is negative,
             * then the characters retrieved are those characters from `start_pos` to
             * the end of the text.
             *
             * Note that positions are specified in characters, not bytes.
             * @param start_pos start of text
             * @param end_pos end of text
             * @returns a pointer to the contents of the widget as a   string. This string is allocated by the `GtkEditable` implementation   and should be freed by the caller.
             */
            get_chars(start_pos: number, end_pos: number): string;
            /**
             * Gets the `GtkEditable` that `editable` is delegating its
             * implementation to.
             *
             * Typically, the delegate is a [class`Gtk`.Text] widget.
             * @returns the delegate `GtkEditable`
             */
            get_delegate(): Editable | null;
            /**
             * Retrieves whether `editable` is editable.
             * @returns %TRUE if @editable is editable.
             */
            get_editable(): boolean;
            /**
             * Gets if undo/redo actions are enabled for `editable`
             * @returns %TRUE if undo is enabled
             */
            get_enable_undo(): boolean;
            /**
             * Retrieves the desired maximum width of `editable,` in characters.
             * @returns the maximum width of the entry, in characters
             */
            get_max_width_chars(): number;
            /**
             * Retrieves the current position of the cursor relative
             * to the start of the content of the editable.
             *
             * Note that this position is in characters, not in bytes.
             * @returns the cursor position
             */
            get_position(): number;
            /**
             * Retrieves the selection bound of the editable.
             *
             * `start_pos` will be filled with the start of the selection and
             * `end_pos` with end. If no text was selected both will be identical
             * and %FALSE will be returned.
             *
             * Note that positions are specified in characters, not bytes.
             * @returns %TRUE if there is a non-empty selection, %FALSE otherwise
             */
            get_selection_bounds(): [boolean, number, number];
            /**
             * Retrieves the contents of `editable`.
             *
             * The returned string is owned by GTK and must not be modified or freed.
             * @returns a pointer to the contents of the editable
             */
            get_text(): string;
            /**
             * Gets the number of characters of space reserved
             * for the contents of the editable.
             * @returns number of chars to request space for, or negative if unset
             */
            get_width_chars(): number;
            /**
             * Sets up a delegate for `GtkEditable`.
             *
             * This is assuming that the get_delegate vfunc in the `GtkEditable`
             * interface has been set up for the `editable'`s type.
             *
             * This is a helper function that should be called in instance init,
             * after creating the delegate object.
             */
            init_delegate(): void;
            /**
             * Inserts `length` bytes of `text` into the contents of the
             * widget, at position `position`.
             *
             * Note that the position is in characters, not in bytes.
             * The function updates `position` to point after the newly
             * inserted text.
             * @param text the text to insert
             * @param length the length of the text in bytes, or -1
             * @param position location of the position text will be inserted at
             */
            insert_text(text: string, length: number, position: number): number;
            /**
             * Selects a region of text.
             *
             * The characters that are selected are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters selected are those characters from
             * `start_pos` to  the end of the text.
             *
             * Note that positions are specified in characters, not bytes.
             * @param start_pos start of region
             * @param end_pos end of region
             */
            select_region(start_pos: number, end_pos: number): void;
            /**
             * Sets the alignment for the contents of the editable.
             *
             * This controls the horizontal positioning of the contents when
             * the displayed text is shorter than the width of the editable.
             * @param xalign The horizontal alignment, from 0 (left) to 1 (right).   Reversed for RTL layouts
             */
            set_alignment(xalign: number): void;
            /**
             * Determines if the user can edit the text in the editable widget.
             * @param is_editable %TRUE if the user is allowed to edit the text   in the widget
             */
            set_editable(is_editable: boolean): void;
            /**
             * If enabled, changes to `editable` will be saved for undo/redo
             * actions.
             *
             * This results in an additional copy of text changes and are not
             * stored in secure memory. As such, undo is forcefully disabled
             * when [property`Gtk`.Text:visibility] is set to %FALSE.
             * @param enable_undo if undo/redo should be enabled
             */
            set_enable_undo(enable_undo: boolean): void;
            /**
             * Sets the desired maximum width in characters of `editable`.
             * @param n_chars the new desired maximum width, in characters
             */
            set_max_width_chars(n_chars: number): void;
            /**
             * Sets the cursor position in the editable to the given value.
             *
             * The cursor is displayed before the character with the given (base 0)
             * index in the contents of the editable. The value must be less than
             * or equal to the number of characters in the editable. A value of -1
             * indicates that the position should be set after the last character
             * of the editable. Note that `position` is in characters, not in bytes.
             * @param position the position of the cursor
             */
            set_position(position: number): void;
            /**
             * Sets the text in the editable to the given value.
             *
             * This is replacing the current contents.
             * @param text the text to set
             */
            set_text(text: string): void;
            /**
             * Changes the size request of the editable to be about the
             * right size for `n_chars` characters.
             *
             * Note that it changes the size request, the size can still
             * be affected by how you pack the widget into containers.
             * If `n_chars` is -1, the size reverts to the default size.
             * @param n_chars width in chars
             */
            set_width_chars(n_chars: number): void;
            vfunc_changed(): void;
            /**
             * Deletes a sequence of characters.
             *
             * The characters that are deleted are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters deleted are those from `start_pos` to
             * the end of the text.
             *
             * Note that the positions are specified in characters, not bytes.
             * @param start_pos start position
             * @param end_pos end position
             */
            vfunc_delete_text(start_pos: number, end_pos: number): void;
            /**
             * Deletes a sequence of characters.
             *
             * The characters that are deleted are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters deleted are those from `start_pos` to
             * the end of the text.
             *
             * Note that the positions are specified in characters, not bytes.
             * @param start_pos start position
             * @param end_pos end position
             */
            vfunc_do_delete_text(start_pos: number, end_pos: number): void;
            /**
             * Inserts `length` bytes of `text` into the contents of the
             * widget, at position `position`.
             *
             * Note that the position is in characters, not in bytes.
             * The function updates `position` to point after the newly
             * inserted text.
             * @param text the text to insert
             * @param length the length of the text in bytes, or -1
             * @param position location of the position text will be inserted at
             */
            vfunc_do_insert_text(text: string, length: number, position: number): number;
            /**
             * Gets the `GtkEditable` that `editable` is delegating its
             * implementation to.
             *
             * Typically, the delegate is a [class`Gtk`.Text] widget.
             */
            vfunc_get_delegate(): Editable | null;
            /**
             * Retrieves the selection bound of the editable.
             *
             * `start_pos` will be filled with the start of the selection and
             * `end_pos` with end. If no text was selected both will be identical
             * and %FALSE will be returned.
             *
             * Note that positions are specified in characters, not bytes.
             */
            vfunc_get_selection_bounds(): [boolean, number, number];
            /**
             * Retrieves the contents of `editable`.
             *
             * The returned string is owned by GTK and must not be modified or freed.
             */
            vfunc_get_text(): string;
            /**
             * Inserts `length` bytes of `text` into the contents of the
             * widget, at position `position`.
             *
             * Note that the position is in characters, not in bytes.
             * The function updates `position` to point after the newly
             * inserted text.
             * @param text the text to insert
             * @param length the length of the text in bytes, or -1
             * @param position location of the position text will be inserted at
             */
            vfunc_insert_text(text: string, length: number, position: number): number;
            /**
             * Selects a region of text.
             *
             * The characters that are selected are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters selected are those characters from
             * `start_pos` to  the end of the text.
             *
             * Note that positions are specified in characters, not bytes.
             * @param start_pos start of region
             * @param end_pos end of region
             */
            vfunc_set_selection_bounds(start_pos: number, end_pos: number): void;
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace Spinner {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                spinning: boolean;
            }
        }

        /**
         * A `GtkSpinner` widget displays an icon-size spinning animation.
         *
         * It is often used as an alternative to a [class`Gtk`.ProgressBar]
         * for displaying indefinite activity, instead of actual progress.
         *
         * ![An example GtkSpinner](spinner.png)
         *
         * To start the animation, use [method`Gtk`.Spinner.start], to stop it
         * use [method`Gtk`.Spinner.stop].
         *
         * # CSS nodes
         *
         * `GtkSpinner` has a single CSS node with the name spinner.
         * When the animation is active, the :checked pseudoclass is
         * added to this node.
         */
        class Spinner extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<Spinner>;

            // Properties

            /**
             * Whether the spinner is spinning
             */
            get spinning(): boolean;
            set spinning(val: boolean);

            // Constructors

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

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

            static ['new'](): Spinner;

            // Methods

            /**
             * Returns whether the spinner is spinning.
             * @returns %TRUE if the spinner is active
             */
            get_spinning(): boolean;
            /**
             * Sets the activity of the spinner.
             * @param spinning whether the spinner should be spinning
             */
            set_spinning(spinning: boolean): void;
            /**
             * Starts the animation of the spinner.
             */
            start(): void;
            /**
             * Stops the animation of the spinner.
             */
            stop(): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Stack {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                hhomogeneous: boolean;
                interpolate_size: boolean;
                interpolateSize: boolean;
                pages: SelectionModel;
                transition_duration: number;
                transitionDuration: number;
                transition_running: boolean;
                transitionRunning: boolean;
                transition_type: StackTransitionType;
                transitionType: StackTransitionType;
                vhomogeneous: boolean;
                visible_child: Widget;
                visibleChild: Widget;
                visible_child_name: string;
                visibleChildName: string;
            }
        }

        /**
         * `GtkStack` is a container which only shows one of its children
         * at a time.
         *
         * In contrast to `GtkNotebook`, `GtkStack` does not provide a means
         * for users to change the visible child. Instead, a separate widget
         * such as [class`Gtk`.StackSwitcher] or [class`Gtk`.StackSidebar] can
         * be used with `GtkStack` to provide this functionality.
         *
         * Transitions between pages can be animated as slides or fades. This
         * can be controlled with [method`Gtk`.Stack.set_transition_type].
         * These animations respect the [property`Gtk`.Settings:gtk-enable-animations]
         * setting.
         *
         * `GtkStack` maintains a [class`Gtk`.StackPage] object for each added
         * child, which holds additional per-child properties. You
         * obtain the `GtkStackPage` for a child with [method`Gtk`.Stack.get_page]
         * and you can obtain a `GtkSelectionModel` containing all the pages
         * with [method`Gtk`.Stack.get_pages].
         *
         * # GtkStack as GtkBuildable
         *
         * To set child-specific properties in a .ui file, create `GtkStackPage`
         * objects explicitly, and set the child widget as a property on it:
         *
         * ```xml
         *   <object class="GtkStack" id="stack">
         *     <child>
         *       <object class="GtkStackPage">
         *         <property name="name">page1</property>
         *         <property name="title">In the beginning…</property>
         *         <property name="child">
         *           <object class="GtkLabel">
         *             <property name="label">It was dark</property>
         *           </object>
         *         </property>
         *       </object>
         *     </child>
         * ```
         *
         * # CSS nodes
         *
         * `GtkStack` has a single CSS node named stack.
         *
         * # Accessibility
         *
         * `GtkStack` uses the %GTK_ACCESSIBLE_ROLE_TAB_PANEL for the stack
         * pages, which are the accessible parent objects of the child widgets.
         */
        class Stack extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<Stack>;

            // Properties

            /**
             * %TRUE if the stack allocates the same width for all children.
             */
            get hhomogeneous(): boolean;
            set hhomogeneous(val: boolean);
            /**
             * Whether or not the size should smoothly change during the transition.
             */
            get interpolate_size(): boolean;
            set interpolate_size(val: boolean);
            /**
             * Whether or not the size should smoothly change during the transition.
             */
            get interpolateSize(): boolean;
            set interpolateSize(val: boolean);
            /**
             * A selection model with the stack pages.
             */
            get pages(): SelectionModel;
            /**
             * The animation duration, in milliseconds.
             */
            get transition_duration(): number;
            set transition_duration(val: number);
            /**
             * The animation duration, in milliseconds.
             */
            get transitionDuration(): number;
            set transitionDuration(val: number);
            /**
             * Whether or not the transition is currently running.
             */
            get transition_running(): boolean;
            /**
             * Whether or not the transition is currently running.
             */
            get transitionRunning(): boolean;
            /**
             * The type of animation used to transition.
             */
            get transition_type(): StackTransitionType;
            set transition_type(val: StackTransitionType);
            /**
             * The type of animation used to transition.
             */
            get transitionType(): StackTransitionType;
            set transitionType(val: StackTransitionType);
            /**
             * %TRUE if the stack allocates the same height for all children.
             */
            get vhomogeneous(): boolean;
            set vhomogeneous(val: boolean);
            /**
             * The widget currently visible in the stack.
             */
            get visible_child(): Widget;
            set visible_child(val: Widget);
            /**
             * The widget currently visible in the stack.
             */
            get visibleChild(): Widget;
            set visibleChild(val: Widget);
            /**
             * The name of the widget currently visible in the stack.
             */
            get visible_child_name(): string;
            set visible_child_name(val: string);
            /**
             * The name of the widget currently visible in the stack.
             */
            get visibleChildName(): string;
            set visibleChildName(val: string);

            // Constructors

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

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

            static ['new'](): Stack;

            // Methods

            /**
             * Adds a child to `stack`.
             * @param child the widget to add
             * @returns the `GtkStackPage` for @child
             */
            add_child(child: Widget): StackPage;
            /**
             * Adds a child to `stack`.
             *
             * The child is identified by the `name`.
             * @param child the widget to add
             * @param name the name for @child
             * @returns the `GtkStackPage` for @child
             */
            add_named(child: Widget, name?: string | null): StackPage;
            /**
             * Adds a child to `stack`.
             *
             * The child is identified by the `name`. The `title`
             * will be used by `GtkStackSwitcher` to represent
             * `child` in a tab bar, so it should be short.
             * @param child the widget to add
             * @param name the name for @child
             * @param title a human-readable title for @child
             * @returns the `GtkStackPage` for @child
             */
            add_titled(child: Widget, name: string | null, title: string): StackPage;
            /**
             * Finds the child with the name given as the argument.
             *
             * Returns %NULL if there is no child with this name.
             * @param name the name of the child to find
             * @returns the requested child   of the `GtkStack`
             */
            get_child_by_name(name: string): Widget | null;
            /**
             * Gets whether `stack` is horizontally homogeneous.
             * @returns whether @stack is horizontally homogeneous.
             */
            get_hhomogeneous(): boolean;
            /**
             * Returns whether the `GtkStack` is set up to interpolate between
             * the sizes of children on page switch.
             * @returns %TRUE if child sizes are interpolated
             */
            get_interpolate_size(): boolean;
            /**
             * Returns the `GtkStackPage` object for `child`.
             * @param child a child of @stack
             * @returns the `GtkStackPage` for @child
             */
            get_page(child: Widget): StackPage;
            /**
             * Returns a `GListModel` that contains the pages of the stack.
             *
             * This can be used to keep an up-to-date view. The model also
             * implements [iface`Gtk`.SelectionModel] and can be used to track
             * and modify the visible page.
             * @returns a `GtkSelectionModel` for the stack's children
             */
            get_pages(): SelectionModel;
            /**
             * Returns the amount of time (in milliseconds) that
             * transitions between pages in `stack` will take.
             * @returns the transition duration
             */
            get_transition_duration(): number;
            /**
             * Returns whether the `stack` is currently in a transition from one page to
             * another.
             * @returns %TRUE if the transition is currently running, %FALSE otherwise.
             */
            get_transition_running(): boolean;
            /**
             * Gets the type of animation that will be used
             * for transitions between pages in `stack`.
             * @returns the current transition type of @stack
             */
            get_transition_type(): StackTransitionType;
            /**
             * Gets whether `stack` is vertically homogeneous.
             * @returns whether @stack is vertically homogeneous.
             */
            get_vhomogeneous(): boolean;
            /**
             * Gets the currently visible child of `stack`.
             *
             * Returns %NULL if there are no visible children.
             * @returns the visible child of the `GtkStack`
             */
            get_visible_child(): Widget | null;
            /**
             * Returns the name of the currently visible child of `stack`.
             *
             * Returns %NULL if there is no visible child.
             * @returns the name of the visible child   of the `GtkStack`
             */
            get_visible_child_name(): string | null;
            /**
             * Removes a child widget from `stack`.
             * @param child the child to remove
             */
            remove(child: Widget): void;
            /**
             * Sets the `GtkStack` to be horizontally homogeneous or not.
             *
             * If it is homogeneous, the `GtkStack` will request the same
             * width for all its children. If it isn't, the stack
             * may change width when a different child becomes visible.
             * @param hhomogeneous %TRUE to make @stack horizontally homogeneous
             */
            set_hhomogeneous(hhomogeneous: boolean): void;
            /**
             * Sets whether or not `stack` will interpolate its size when
             * changing the visible child.
             *
             * If the [property`Gtk`.Stack:interpolate-size] property is set
             * to %TRUE, `stack` will interpolate its size between the current
             * one and the one it'll take after changing the visible child,
             * according to the set transition duration.
             * @param interpolate_size the new value
             */
            set_interpolate_size(interpolate_size: boolean): void;
            /**
             * Sets the duration that transitions between pages in `stack`
             * will take.
             * @param duration the new duration, in milliseconds
             */
            set_transition_duration(duration: number): void;
            /**
             * Sets the type of animation that will be used for
             * transitions between pages in `stack`.
             *
             * Available types include various kinds of fades and slides.
             *
             * The transition type can be changed without problems
             * at runtime, so it is possible to change the animation
             * based on the page that is about to become current.
             * @param transition the new transition type
             */
            set_transition_type(transition: StackTransitionType | null): void;
            /**
             * Sets the `GtkStack` to be vertically homogeneous or not.
             *
             * If it is homogeneous, the `GtkStack` will request the same
             * height for all its children. If it isn't, the stack
             * may change height when a different child becomes visible.
             * @param vhomogeneous %TRUE to make @stack vertically homogeneous
             */
            set_vhomogeneous(vhomogeneous: boolean): void;
            /**
             * Makes `child` the visible child of `stack`.
             *
             * If `child` is different from the currently visible child,
             * the transition between the two will be animated with the
             * current transition type of `stack`.
             *
             * Note that the `child` widget has to be visible itself
             * (see [method`Gtk`.Widget.show]) in order to become the visible
             * child of `stack`.
             * @param child a child of @stack
             */
            set_visible_child(child: Widget): void;
            /**
             * Makes the child with the given name visible.
             *
             * Note that the child widget has to be visible itself
             * (see [method`Gtk`.Widget.show]) in order to become the visible
             * child of `stack`.
             * @param name the name of the child to make visible
             * @param transition the transition type to use
             */
            set_visible_child_full(name: string, transition: StackTransitionType | null): void;
            /**
             * Makes the child with the given name visible.
             *
             * If `child` is different from the currently visible child,
             * the transition between the two will be animated with the
             * current transition type of `stack`.
             *
             * Note that the child widget has to be visible itself
             * (see [method`Gtk`.Widget.show]) in order to become the visible
             * child of `stack`.
             * @param name the name of the child to make visible
             */
            set_visible_child_name(name: string): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace StackPage {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps, Accessible.ConstructorProps {
                child: Widget;
                icon_name: string;
                iconName: string;
                name: string;
                needs_attention: boolean;
                needsAttention: boolean;
                title: string;
                use_underline: boolean;
                useUnderline: boolean;
                visible: boolean;
            }
        }

        /**
         * `GtkStackPage` is an auxiliary class used by `GtkStack`.
         */
        class StackPage extends GObject.Object implements Accessible {
            static $gtype: GObject.GType<StackPage>;

            // Properties

            /**
             * The child that this page is for.
             */
            get child(): Widget;
            /**
             * The icon name of the child page.
             */
            get icon_name(): string;
            set icon_name(val: string);
            /**
             * The icon name of the child page.
             */
            get iconName(): string;
            set iconName(val: string);
            /**
             * The name of the child page.
             */
            get name(): string;
            set name(val: string);
            /**
             * Whether the page requires the user attention.
             *
             * This is used by the [class`Gtk`.StackSwitcher] to change the
             * appearance of the corresponding button when a page needs
             * attention and it is not the current one.
             */
            get needs_attention(): boolean;
            set needs_attention(val: boolean);
            /**
             * Whether the page requires the user attention.
             *
             * This is used by the [class`Gtk`.StackSwitcher] to change the
             * appearance of the corresponding button when a page needs
             * attention and it is not the current one.
             */
            get needsAttention(): boolean;
            set needsAttention(val: boolean);
            /**
             * The title of the child page.
             */
            get title(): string;
            set title(val: string);
            /**
             * If set, an underline in the title indicates a mnemonic.
             */
            get use_underline(): boolean;
            set use_underline(val: boolean);
            /**
             * If set, an underline in the title indicates a mnemonic.
             */
            get useUnderline(): boolean;
            set useUnderline(val: boolean);
            /**
             * Whether this page is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);

            // Constructors

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

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

            // Methods

            /**
             * Returns the stack child to which `self` belongs.
             * @returns the child to which @self belongs
             */
            get_child(): Widget;
            /**
             * Returns the icon name of the page.
             * @returns The value of the [property@Gtk.StackPage:icon-name] property
             */
            get_icon_name(): string | null;
            /**
             * Returns the name of the page.
             * @returns The value of the [property@Gtk.StackPage:name] property
             */
            get_name(): string | null;
            /**
             * Returns whether the page is marked as “needs attention”.
             * @returns The value of the [property@Gtk.StackPage:needs-attention]   property.
             */
            get_needs_attention(): boolean;
            /**
             * Gets the page title.
             * @returns The value of the [property@Gtk.StackPage:title] property
             */
            get_title(): string | null;
            /**
             * Gets whether underlines in the page title indicate mnemonics.
             * @returns The value of the [property@Gtk.StackPage:use-underline] property
             */
            get_use_underline(): boolean;
            /**
             * Returns whether `page` is visible in its `GtkStack`.
             *
             * This is independent from the [property`Gtk`.Widget:visible]
             * property of its widget.
             * @returns %TRUE if @page is visible
             */
            get_visible(): boolean;
            /**
             * Sets the icon name of the page.
             * @param setting the new value to set
             */
            set_icon_name(setting: string): void;
            /**
             * Sets the name of the page.
             * @param setting the new value to set
             */
            set_name(setting: string): void;
            /**
             * Sets whether the page is marked as “needs attention”.
             * @param setting the new value to set
             */
            set_needs_attention(setting: boolean): void;
            /**
             * Sets the page title.
             * @param setting the new value to set
             */
            set_title(setting: string): void;
            /**
             * Sets whether underlines in the page title indicate mnemonics.
             * @param setting the new value to set
             */
            set_use_underline(setting: boolean): void;
            /**
             * Sets whether `page` is visible in its `GtkStack`.
             * @param visible The new property value
             */
            set_visible(visible: boolean): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace StackSidebar {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                stack: Stack;
            }
        }

        /**
         * A `GtkStackSidebar` uses a sidebar to switch between `GtkStack` pages.
         *
         * In order to use a `GtkStackSidebar`, you simply use a `GtkStack` to
         * organize your UI flow, and add the sidebar to your sidebar area. You
         * can use [method`Gtk`.StackSidebar.set_stack] to connect the `GtkStackSidebar`
         * to the `GtkStack`.
         *
         * # CSS nodes
         *
         * `GtkStackSidebar` has a single CSS node with name stacksidebar and
         * style class .sidebar.
         *
         * When circumstances require it, `GtkStackSidebar` adds the
         * .needs-attention style class to the widgets representing the stack
         * pages.
         */
        class StackSidebar extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<StackSidebar>;

            // Properties

            /**
             * The stack.
             */
            get stack(): Stack;
            set stack(val: Stack);

            // Constructors

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

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

            static ['new'](): StackSidebar;

            // Methods

            /**
             * Retrieves the stack.
             * @returns the associated `GtkStack` or   %NULL if none has been set explicitly
             */
            get_stack(): Stack | null;
            /**
             * Set the `GtkStack` associated with this `GtkStackSidebar`.
             *
             * The sidebar widget will automatically update according to
             * the order and items within the given `GtkStack`.
             * @param stack a `GtkStack`
             */
            set_stack(stack: Stack): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace StackSwitcher {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Orientable.ConstructorProps {
                stack: Stack;
            }
        }

        /**
         * The `GtkStackSwitcher` shows a row of buttons to switch between `GtkStack`
         * pages.
         *
         * ![An example GtkStackSwitcher](stackswitcher.png)
         *
         * It acts as a controller for the associated `GtkStack`.
         *
         * All the content for the buttons comes from the properties of the stacks
         * [class`Gtk`.StackPage] objects; the button visibility in a `GtkStackSwitcher`
         * widget is controlled by the visibility of the child in the `GtkStack`.
         *
         * It is possible to associate multiple `GtkStackSwitcher` widgets
         * with the same `GtkStack` widget.
         *
         * # CSS nodes
         *
         * `GtkStackSwitcher` has a single CSS node named stackswitcher and
         * style class .stack-switcher.
         *
         * When circumstances require it, `GtkStackSwitcher` adds the
         * .needs-attention style class to the widgets representing the
         * stack pages.
         *
         * # Accessibility
         *
         * `GtkStackSwitcher` uses the %GTK_ACCESSIBLE_ROLE_TAB_LIST role
         * and uses the %GTK_ACCESSIBLE_ROLE_TAB for its buttons.
         *
         * # Orientable
         *
         * Since GTK 4.4, `GtkStackSwitcher` implements `GtkOrientable` allowing
         * the stack switcher to be made vertical with
         * `gtk_orientable_set_orientation()`.
         */
        class StackSwitcher extends Widget implements Accessible, Buildable, ConstraintTarget, Orientable {
            static $gtype: GObject.GType<StackSwitcher>;

            // Properties

            /**
             * The stack.
             */
            get stack(): Stack;
            set stack(val: Stack);

            // Constructors

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

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

            static ['new'](): StackSwitcher;

            // Methods

            /**
             * Retrieves the stack.
             * @returns the stack
             */
            get_stack(): Stack | null;
            /**
             * Sets the stack to control.
             * @param stack a `GtkStack`
             */
            set_stack(stack?: Stack | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Statusbar {
            // Signal callback interfaces

            interface TextPopped {
                (context_id: number, text: string): void;
            }

            interface TextPushed {
                (context_id: number, text: string): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {}
        }

        /**
         * A `GtkStatusbar` widget is usually placed along the bottom of an application's
         * main [class`Gtk`.Window].
         *
         * ![An example GtkStatusbar](statusbar.png)
         *
         * A `GtkStatusBar` may provide a regular commentary of the application's
         * status (as is usually the case in a web browser, for example), or may be
         * used to simply output a message when the status changes, (when an upload
         * is complete in an FTP client, for example).
         *
         * Status bars in GTK maintain a stack of messages. The message at
         * the top of the each bar’s stack is the one that will currently be displayed.
         *
         * Any messages added to a statusbar’s stack must specify a context id that
         * is used to uniquely identify the source of a message. This context id can
         * be generated by [method`Gtk`.Statusbar.get_context_id], given a message and
         * the statusbar that it will be added to. Note that messages are stored in a
         * stack, and when choosing which message to display, the stack structure is
         * adhered to, regardless of the context identifier of a message.
         *
         * One could say that a statusbar maintains one stack of messages for
         * display purposes, but allows multiple message producers to maintain
         * sub-stacks of the messages they produced (via context ids).
         *
         * Status bars are created using [ctor`Gtk`.Statusbar.new].
         *
         * Messages are added to the bar’s stack with [method`Gtk`.Statusbar.push].
         *
         * The message at the top of the stack can be removed using
         * [method`Gtk`.Statusbar.pop]. A message can be removed from anywhere in the
         * stack if its message id was recorded at the time it was added. This is done
         * using [method`Gtk`.Statusbar.remove].
         *
         * ## CSS node
         *
         * `GtkStatusbar` has a single CSS node with name `statusbar`.
         */
        class Statusbar extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<Statusbar>;

            // Constructors

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

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

            static ['new'](): Statusbar;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'text-popped', callback: (_source: this, context_id: number, text: string) => void): number;
            connect_after(
                signal: 'text-popped',
                callback: (_source: this, context_id: number, text: string) => void,
            ): number;
            emit(signal: 'text-popped', context_id: number, text: string): void;
            connect(signal: 'text-pushed', callback: (_source: this, context_id: number, text: string) => void): number;
            connect_after(
                signal: 'text-pushed',
                callback: (_source: this, context_id: number, text: string) => void,
            ): number;
            emit(signal: 'text-pushed', context_id: number, text: string): void;

            // Methods

            /**
             * Returns a new context identifier, given a description
             * of the actual context.
             *
             * Note that the description is not shown in the UI.
             * @param context_description textual description of what context   the new message is being used in
             * @returns an integer id
             */
            get_context_id(context_description: string): number;
            /**
             * Removes the first message in the `GtkStatusbar`’s stack
             * with the given context id.
             *
             * Note that this may not change the displayed message,
             * if the message at the top of the stack has a different
             * context id.
             * @param context_id a context identifier
             */
            pop(context_id: number): void;
            /**
             * Pushes a new message onto a statusbar’s stack.
             * @param context_id the message’s context id, as returned by    gtk_statusbar_get_context_id()
             * @param text the message to add to the statusbar
             * @returns a message id that can be used with   [method@Gtk.Statusbar.remove].
             */
            push(context_id: number, text: string): number;
            /**
             * Forces the removal of a message from a statusbar’s stack.
             * The exact `context_id` and `message_id` must be specified.
             * @param context_id a context identifier
             * @param message_id a message identifier, as returned by [method@Gtk.Statusbar.push]
             */
            remove(context_id: number, message_id: number): void;
            /**
             * Forces the removal of all messages from a statusbar's
             * stack with the exact `context_id`.
             * @param context_id a context identifier
             */
            remove_all(context_id: number): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace StringFilter {
            // Constructor properties interface

            interface ConstructorProps extends Filter.ConstructorProps {
                expression: Expression;
                ignore_case: boolean;
                ignoreCase: boolean;
                match_mode: StringFilterMatchMode;
                matchMode: StringFilterMatchMode;
                search: string;
            }
        }

        /**
         * `GtkStringFilter` determines whether to include items by comparing
         * strings to a fixed search term.
         *
         * The strings are obtained from the items by evaluating a `GtkExpression`
         * set with [method`Gtk`.StringFilter.set_expression], and they are
         * compared against a search term set with [method`Gtk`.StringFilter.set_search].
         *
         * `GtkStringFilter` has several different modes of comparison - it
         * can match the whole string, just a prefix, or any substring. Use
         * [method`Gtk`.StringFilter.set_match_mode] choose a mode.
         *
         * It is also possible to make case-insensitive comparisons, with
         * [method`Gtk`.StringFilter.set_ignore_case].
         */
        class StringFilter extends Filter {
            static $gtype: GObject.GType<StringFilter>;

            // Properties

            /**
             * The expression to evaluate on item to get a string to compare with.
             */
            get expression(): Expression;
            set expression(val: Expression);
            /**
             * If matching is case sensitive.
             */
            get ignore_case(): boolean;
            set ignore_case(val: boolean);
            /**
             * If matching is case sensitive.
             */
            get ignoreCase(): boolean;
            set ignoreCase(val: boolean);
            /**
             * If exact matches are necessary or if substrings are allowed.
             */
            get match_mode(): StringFilterMatchMode;
            set match_mode(val: StringFilterMatchMode);
            /**
             * If exact matches are necessary or if substrings are allowed.
             */
            get matchMode(): StringFilterMatchMode;
            set matchMode(val: StringFilterMatchMode);
            /**
             * The search term.
             */
            get search(): string;
            set search(val: string);

            // Constructors

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

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

            static ['new'](expression?: Expression | null): StringFilter;

            // Methods

            /**
             * Gets the expression that the string filter uses to
             * obtain strings from items.
             * @returns a `GtkExpression`
             */
            get_expression(): Expression | null;
            /**
             * Returns whether the filter ignores case differences.
             * @returns %TRUE if the filter ignores case
             */
            get_ignore_case(): boolean;
            /**
             * Returns the match mode that the filter is using.
             * @returns the match mode of the filter
             */
            get_match_mode(): StringFilterMatchMode;
            /**
             * Gets the search term.
             * @returns The search term
             */
            get_search(): string | null;
            /**
             * Sets the expression that the string filter uses to
             * obtain strings from items.
             *
             * The expression must have a value type of %G_TYPE_STRING.
             * @param expression a `GtkExpression`
             */
            set_expression(expression?: Expression | null): void;
            /**
             * Sets whether the filter ignores case differences.
             * @param ignore_case %TRUE to ignore case
             */
            set_ignore_case(ignore_case: boolean): void;
            /**
             * Sets the match mode for the filter.
             * @param mode the new match mode
             */
            set_match_mode(mode: StringFilterMatchMode | null): void;
            /**
             * Sets the string to search for.
             * @param search The string to search for   or %NULL to clear the search
             */
            set_search(search?: string | null): void;
        }

        namespace StringList {
            // Constructor properties interface

            interface ConstructorProps<A extends GObject.Object = StringObject>
                extends GObject.Object.ConstructorProps,
                    Gio.ListModel.ConstructorProps,
                    Buildable.ConstructorProps {
                item_type: GObject.GType;
                itemType: GObject.GType;
                n_items: number;
                nItems: number;
                strings: string[];
            }
        }

        /**
         * `GtkStringList` is a list model that wraps an array of strings.
         *
         * The objects in the model are of type [class`Gtk`.StringObject] and have
         * a "string" property that can be used inside expressions.
         *
         * `GtkStringList` is well-suited for any place where you would
         * typically use a `char*[]`, but need a list model.
         *
         * ## GtkStringList as GtkBuildable
         *
         * The `GtkStringList` implementation of the `GtkBuildable` interface
         * supports adding items directly using the `<items>` element and
         * specifying `<item>` elements for each item. Each `<item>` element
         * supports the regular translation attributes “translatable”,
         * “context” and “comments”.
         *
         * Here is a UI definition fragment specifying a `GtkStringList`
         *
         * ```xml
         * <object class="GtkStringList">
         *   <items>
         *     <item translatable="yes">Factory</item>
         *     <item translatable="yes">Home</item>
         *     <item translatable="yes">Subway</item>
         *   </items>
         * </object>
         * ```
         */
        class StringList<A extends GObject.Object = StringObject>
            extends GObject.Object
            implements Gio.ListModel<A>, Buildable
        {
            static $gtype: GObject.GType<StringList>;

            // Properties

            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get item_type(): GObject.GType;
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get itemType(): GObject.GType;
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get n_items(): number;
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get nItems(): number;
            /**
             * The strings in the model.
             */
            set strings(val: string[]);

            // Constructors

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

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

            static ['new'](strings?: string[] | null): StringList;

            // Methods

            /**
             * Appends `string` to `self`.
             *
             * The `string` will be copied. See
             * [method`Gtk`.StringList.take] for a way to avoid that.
             * @param string the string to insert
             */
            append(string: string): void;
            /**
             * Gets the string that is at `position` in `self`.
             *
             * If `self` does not contain `position` items, %NULL is returned.
             *
             * This function returns the const char *. To get the
             * object wrapping it, use g_list_model_get_item().
             * @param position the position to get the string for
             * @returns the string at the given position
             */
            get_string(position: number): string | null;
            /**
             * Removes the string at `position` from `self`.
             *
             * `position` must be smaller than the current
             * length of the list.
             * @param position the position of the string that is to be removed
             */
            remove(position: number): void;
            /**
             * Changes `self` by removing `n_removals` strings and adding `additions`
             * to it.
             *
             * This function is more efficient than [method`Gtk`.StringList.append]
             * and [method`Gtk`.StringList.remove], because it only emits the
             * ::items-changed signal once for the change.
             *
             * This function copies the strings in `additions`.
             *
             * The parameters `position` and `n_removals` must be correct (ie:
             * `position` + `n_removals` must be less than or equal to the length
             * of the list at the time this function is called).
             * @param position the position at which to make the change
             * @param n_removals the number of strings to remove
             * @param additions The strings to add
             */
            splice(position: number, n_removals: number, additions?: string[] | null): void;
            /**
             * Adds `string` to self at the end, and takes
             * ownership of it.
             *
             * This variant of [method`Gtk`.StringList.append]
             * is convenient for formatting strings:
             *
             * ```c
             * gtk_string_list_take (self, g_strdup_print ("%d dollars", lots));
             * ```
             * @param string the string to insert
             */
            take(string: string): void;

            // Inherited methods
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             * @returns the #GType of the items contained in @list.
             */
            get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             * @returns the number of items in @list.
             */
            get_n_items(): number;
            /**
             * Get the item at `position`.
             *
             * If `position` is greater than the number of items in `list,` %NULL is
             * returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.
             *
             * This function is meant to be used by language bindings in place
             * of g_list_model_get_item().
             *
             * See also: g_list_model_get_n_items()
             * @param position the position of the item to fetch
             * @returns the object at @position.
             */
            get_item(position: number): A | null;
            /**
             * Emits the #GListModel::items-changed signal on `list`.
             *
             * This function should only be called by classes implementing
             * #GListModel. It has to be called after the internal representation
             * of `list` has been updated, because handlers connected to this signal
             * might query the new state of the list.
             *
             * Implementations must only make changes to the model (as visible to
             * its consumer) in places that will not cause problems for that
             * consumer.  For models that are driven directly by a write API (such
             * as #GListStore), changes can be reported in response to uses of that
             * API.  For models that represent remote data, changes should only be
             * made from a fresh mainloop dispatch.  It is particularly not
             * permitted to make changes in response to a call to the #GListModel
             * consumer API.
             *
             * Stated another way: in general, it is assumed that code making a
             * series of accesses to the model via the API, without returning to the
             * mainloop, and without calling other code, will continue to view the
             * same contents of the model.
             * @param position the position at which @list changed
             * @param removed the number of items removed
             * @param added the number of items added
             */
            items_changed(position: number, removed: number, added: number): void;
            /**
             * Get the item at `position`. If `position` is greater than the number of
             * items in `list,` %NULL is returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.  See g_list_model_get_n_items().
             *
             * The same #GObject instance may not appear more than once in a #GListModel.
             * @param position the position of the item to fetch
             */
            vfunc_get_item(position: number): A | null;
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             */
            vfunc_get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             */
            vfunc_get_n_items(): number;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace StringObject {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                string: string;
            }
        }

        /**
         * `GtkStringObject` is the type of items in a `GtkStringList`.
         *
         * A `GtkStringObject` is a wrapper around a `const char*`; it has
         * a [property`Gtk`.StringObject:string] property that can be used
         * for property bindings and expressions.
         */
        class StringObject extends GObject.Object {
            static $gtype: GObject.GType<StringObject>;

            // Properties

            /**
             * The string.
             */
            get string(): string;

            // Constructors

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

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

            static ['new'](string: string): StringObject;

            // Methods

            /**
             * Returns the string contained in a `GtkStringObject`.
             * @returns the string of @self
             */
            get_string(): string;
        }

        namespace StringSorter {
            // Constructor properties interface

            interface ConstructorProps extends Sorter.ConstructorProps {
                collation: Collation;
                expression: Expression;
                ignore_case: boolean;
                ignoreCase: boolean;
            }
        }

        /**
         * `GtkStringSorter` is a `GtkSorter` that compares strings.
         *
         * It does the comparison in a linguistically correct way using the
         * current locale by normalizing Unicode strings and possibly case-folding
         * them before performing the comparison.
         *
         * To obtain the strings to compare, this sorter evaluates a
         * [class`Gtk`.Expression].
         */
        class StringSorter extends Sorter {
            static $gtype: GObject.GType<StringSorter>;

            // Properties

            /**
             * The collation method to use for sorting.
             *
             * The `GTK_COLLATION_NONE` value is useful when the expression already
             * returns collation keys, or strings that need to be compared byte-by-byte.
             *
             * The default value, `GTK_COLLATION_UNICODE`, compares strings according
             * to the [Unicode collation algorithm](https://www.unicode.org/reports/tr10/).
             */
            get collation(): Collation;
            set collation(val: Collation);
            /**
             * The expression to evaluate on item to get a string to compare with.
             */
            get expression(): Expression;
            set expression(val: Expression);
            /**
             * If sorting is case sensitive.
             */
            get ignore_case(): boolean;
            set ignore_case(val: boolean);
            /**
             * If sorting is case sensitive.
             */
            get ignoreCase(): boolean;
            set ignoreCase(val: boolean);

            // Constructors

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

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

            static ['new'](expression?: Expression | null): StringSorter;

            // Methods

            /**
             * Gets which collation method the sorter uses.
             * @returns The collation method
             */
            get_collation(): Collation;
            /**
             * Gets the expression that is evaluated to obtain strings from items.
             * @returns a `GtkExpression`
             */
            get_expression(): Expression | null;
            /**
             * Gets whether the sorter ignores case differences.
             * @returns %TRUE if @self is ignoring case differences
             */
            get_ignore_case(): boolean;
            /**
             * Sets the collation method to use for sorting.
             * @param collation the collation method
             */
            set_collation(collation: Collation | null): void;
            /**
             * Sets the expression that is evaluated to obtain strings from items.
             *
             * The expression must have the type %G_TYPE_STRING.
             * @param expression a `GtkExpression`
             */
            set_expression(expression?: Expression | null): void;
            /**
             * Sets whether the sorter will ignore case differences.
             * @param ignore_case %TRUE to ignore case differences
             */
            set_ignore_case(ignore_case: boolean): void;
        }

        namespace StyleContext {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                display: Gdk.Display;
            }
        }

        /**
         * `GtkStyleContext` stores styling information affecting a widget.
         *
         * In order to construct the final style information, `GtkStyleContext`
         * queries information from all attached `GtkStyleProviders`. Style
         * providers can be either attached explicitly to the context through
         * [method`Gtk`.StyleContext.add_provider], or to the display through
         * [func`Gtk`.StyleContext.add_provider_for_display]. The resulting
         * style is a combination of all providers’ information in priority order.
         *
         * For GTK widgets, any `GtkStyleContext` returned by
         * [method`Gtk`.Widget.get_style_context] will already have a `GdkDisplay`
         * and RTL/LTR information set. The style context will also be updated
         * automatically if any of these settings change on the widget.
         *
         * ## Style Classes
         *
         * Widgets can add style classes to their context, which can be used to associate
         * different styles by class. The documentation for individual widgets lists
         * which style classes it uses itself, and which style classes may be added by
         * applications to affect their appearance.
         *
         * # Custom styling in UI libraries and applications
         *
         * If you are developing a library with custom widgets that render differently
         * than standard components, you may need to add a `GtkStyleProvider` yourself
         * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority, either a
         * `GtkCssProvider` or a custom object implementing the `GtkStyleProvider`
         * interface. This way themes may still attempt to style your UI elements in
         * a different way if needed so.
         *
         * If you are using custom styling on an applications, you probably want then
         * to make your style information prevail to the theme’s, so you must use
         * a `GtkStyleProvider` with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
         * priority, keep in mind that the user settings in
         * `XDG_CONFIG_HOME/gtk-4.0/gtk.css` will
         * still take precedence over your changes, as it uses the
         * %GTK_STYLE_PROVIDER_PRIORITY_USER priority.
         */
        class StyleContext extends GObject.Object {
            static $gtype: GObject.GType<StyleContext>;

            // Properties

            /**
             * The display of the style context.
             */
            get display(): Gdk.Display;
            set display(val: Gdk.Display);

            // Fields

            parent_object: GObject.Object;

            // Constructors

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

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

            // Static methods

            /**
             * Adds a global style provider to `display,` which will be used
             * in style construction for all `GtkStyleContexts` under `display`.
             *
             * GTK uses this to make styling information from `GtkSettings`
             * available.
             *
             * Note: If both priorities are the same, A `GtkStyleProvider`
             * added through [method`Gtk`.StyleContext.add_provider] takes
             * precedence over another added through this function.
             * @param display a `GdkDisplay`
             * @param provider a `GtkStyleProvider`
             * @param priority the priority of the style provider. The lower   it is, the earlier it will be used in the style construction.   Typically this will be in the range between   %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK and   %GTK_STYLE_PROVIDER_PRIORITY_USER
             */
            static add_provider_for_display(display: Gdk.Display, provider: StyleProvider, priority: number): void;
            /**
             * Removes `provider` from the global style providers list in `display`.
             * @param display a `GdkDisplay`
             * @param provider a `GtkStyleProvider`
             */
            static remove_provider_for_display(display: Gdk.Display, provider: StyleProvider): void;

            // Virtual methods

            vfunc_changed(): void;

            // Methods

            /**
             * Adds a style class to `context,` so later uses of the
             * style context will make use of this new class for styling.
             *
             * In the CSS file format, a `GtkEntry` defining a “search”
             * class, would be matched by:
             *
             * ```css
             * entry.search { ... }
             * ```
             *
             * While any widget defining a “search” class would be
             * matched by:
             * ```css
             * .search { ... }
             * ```
             * @param class_name class name to use in styling
             */
            add_class(class_name: string): void;
            /**
             * Adds a style provider to `context,` to be used in style construction.
             *
             * Note that a style provider added by this function only affects
             * the style of the widget to which `context` belongs. If you want
             * to affect the style of all widgets, use
             * [func`Gtk`.StyleContext.add_provider_for_display].
             *
             * Note: If both priorities are the same, a `GtkStyleProvider`
             * added through this function takes precedence over another added
             * through [func`Gtk`.StyleContext.add_provider_for_display].
             * @param provider a `GtkStyleProvider`
             * @param priority the priority of the style provider. The lower   it is, the earlier it will be used in the style construction.   Typically this will be in the range between   %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK and   %GTK_STYLE_PROVIDER_PRIORITY_USER
             */
            add_provider(provider: StyleProvider, priority: number): void;
            /**
             * Gets the border for a given state as a `GtkBorder`.
             */
            get_border(): Border;
            /**
             * Gets the foreground color for a given state.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the `GdkDisplay` to which `context` is attached.
             * @returns a `GdkDisplay`.
             */
            get_display(): Gdk.Display;
            /**
             * Gets the margin for a given state as a `GtkBorder`.
             */
            get_margin(): Border;
            /**
             * Gets the padding for a given state as a `GtkBorder`.
             */
            get_padding(): Border;
            /**
             * Returns the scale used for assets.
             * @returns the scale
             */
            get_scale(): number;
            /**
             * Returns the state used for style matching.
             *
             * This method should only be used to retrieve the `GtkStateFlags`
             * to pass to `GtkStyleContext` methods, like
             * [method`Gtk`.StyleContext.get_padding].
             * If you need to retrieve the current state of a `GtkWidget`, use
             * [method`Gtk`.Widget.get_state_flags].
             * @returns the state flags
             */
            get_state(): StateFlags;
            /**
             * Returns %TRUE if `context` currently has defined the
             * given class name.
             * @param class_name a class name
             * @returns %TRUE if @context has @class_name defined
             */
            has_class(class_name: string): boolean;
            /**
             * Looks up and resolves a color name in the `context` color map.
             * @param color_name color name to lookup
             * @returns %TRUE if @color_name was found and resolved, %FALSE otherwise
             */
            lookup_color(color_name: string): [boolean, Gdk.RGBA];
            /**
             * Removes `class_name` from `context`.
             * @param class_name class name to remove
             */
            remove_class(class_name: string): void;
            /**
             * Removes `provider` from the style providers list in `context`.
             * @param provider a `GtkStyleProvider`
             */
            remove_provider(provider: StyleProvider): void;
            /**
             * Restores `context` state to a previous stage.
             *
             * See [method`Gtk`.StyleContext.save].
             */
            restore(): void;
            /**
             * Saves the `context` state.
             *
             * This allows temporary modifications done through
             * [method`Gtk`.StyleContext.add_class],
             * [method`Gtk`.StyleContext.remove_class],
             * [method`Gtk`.StyleContext.set_state] to be quickly
             * reverted in one go through [method`Gtk`.StyleContext.restore].
             *
             * The matching call to [method`Gtk`.StyleContext.restore]
             * must be done before GTK returns to the main loop.
             */
            save(): void;
            /**
             * Attaches `context` to the given display.
             *
             * The display is used to add style information from “global”
             * style providers, such as the display's `GtkSettings` instance.
             *
             * If you are using a `GtkStyleContext` returned from
             * [method`Gtk`.Widget.get_style_context], you do not need to
             * call this yourself.
             * @param display a `GdkDisplay`
             */
            set_display(display: Gdk.Display): void;
            /**
             * Sets the scale to use when getting image assets for the style.
             * @param scale scale
             */
            set_scale(scale: number): void;
            /**
             * Sets the state to be used for style matching.
             * @param flags state to represent
             */
            set_state(flags: StateFlags | null): void;
            /**
             * Converts the style context into a string representation.
             *
             * The string representation always includes information about
             * the name, state, id, visibility and style classes of the CSS
             * node that is backing `context`. Depending on the flags, more
             * information may be included.
             *
             * This function is intended for testing and debugging of the
             * CSS implementation in GTK. There are no guarantees about
             * the format of the returned string, it may change.
             * @param flags Flags that determine what to print
             * @returns a newly allocated string representing @context
             */
            to_string(flags: StyleContextPrintFlags | null): string;
        }

        namespace Switch {
            // Signal callback interfaces

            interface Activate {
                (): void;
            }

            interface StateSet {
                (state: boolean): boolean;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Actionable.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                active: boolean;
                state: boolean;
            }
        }

        /**
         * `GtkSwitch` is a "light switch" that has two states: on or off.
         *
         * ![An example GtkSwitch](switch.png)
         *
         * The user can control which state should be active by clicking the
         * empty area, or by dragging the slider.
         *
         * `GtkSwitch` can also express situations where the underlying state changes
         * with a delay. In this case, the slider position indicates the user's recent
         * change (represented by the [property`Gtk`.Switch:active] property), while the
         * trough color indicates the present underlying state (represented by the
         * [property`Gtk`.Switch:state] property).
         *
         * ![GtkSwitch with delayed state change](switch-state.png)
         *
         * See [signal`Gtk`.Switch::state-set] for details.
         *
         * # Shortcuts and Gestures
         *
         * `GtkSwitch` supports pan and drag gestures to move the slider.
         *
         * # CSS nodes
         *
         * ```
         * switch
         * ├── image
         * ├── image
         * ╰── slider
         * ```
         *
         * `GtkSwitch` has four css nodes, the main node with the name switch and
         * subnodes for the slider and the on and off images. Neither of them is
         * using any style classes.
         *
         * # Accessibility
         *
         * `GtkSwitch` uses the %GTK_ACCESSIBLE_ROLE_SWITCH role.
         */
        class Switch extends Widget implements Accessible, Actionable, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<Switch>;

            // Properties

            /**
             * Whether the `GtkSwitch` widget is in its on or off state.
             */
            get active(): boolean;
            set active(val: boolean);
            /**
             * The backend state that is controlled by the switch.
             *
             * Applications should usually set the [property`Gtk`.Switch:active] property,
             * except when indicating a change to the backend state which occurs
             * separately from the user's interaction.
             *
             * See [signal`Gtk`.Switch::state-set] for details.
             */
            get state(): boolean;
            set state(val: boolean);

            // Constructors

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

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

            static ['new'](): Switch;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate', callback: (_source: this) => void): number;
            connect_after(signal: 'activate', callback: (_source: this) => void): number;
            emit(signal: 'activate'): void;
            connect(signal: 'state-set', callback: (_source: this, state: boolean) => boolean): number;
            connect_after(signal: 'state-set', callback: (_source: this, state: boolean) => boolean): number;
            emit(signal: 'state-set', state: boolean): void;

            // Methods

            /**
             * Gets whether the `GtkSwitch` is in its “on” or “off” state.
             * @returns %TRUE if the `GtkSwitch` is active, and %FALSE otherwise
             */
            get_active(): boolean;
            /**
             * Gets the underlying state of the `GtkSwitch`.
             * @returns the underlying state
             */
            get_state(): boolean;
            /**
             * Changes the state of `self` to the desired one.
             * @param is_active %TRUE if @self should be active, and %FALSE otherwise
             */
            set_active(is_active: boolean): void;
            /**
             * Sets the underlying state of the `GtkSwitch`.
             *
             * This function is typically called from a [signal`Gtk`.Switch::state-set]
             * signal handler in order to set up delayed state changes.
             *
             * See [signal`Gtk`.Switch::state-set] for details.
             * @param state the new state
             */
            set_state(state: boolean): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The name of the action with which this widget should be associated.
             */
            get action_name(): string;
            set action_name(val: string);
            /**
             * The name of the action with which this widget should be associated.
             */
            get actionName(): string;
            set actionName(val: string);
            /**
             * The target value of the actionable widget's action.
             */
            get action_target(): GLib.Variant;
            set action_target(val: GLib.Variant);
            /**
             * The target value of the actionable widget's action.
             */
            get actionTarget(): GLib.Variant;
            set actionTarget(val: GLib.Variant);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the action name for `actionable`.
             * @returns the action name
             */
            get_action_name(): string | null;
            /**
             * Gets the current target value of `actionable`.
             * @returns the current target value
             */
            get_action_target_value(): GLib.Variant | null;
            /**
             * Specifies the name of the action with which this widget should be
             * associated.
             *
             * If `action_name` is %NULL then the widget will be unassociated from
             * any previous action.
             *
             * Usually this function is used when the widget is located (or will be
             * located) within the hierarchy of a `GtkApplicationWindow`.
             *
             * Names are of the form “win.save” or “app.quit” for actions on the
             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
             * associated with the window.
             * @param action_name an action name
             */
            set_action_name(action_name?: string | null): void;
            /**
             * Sets the target value of an actionable widget.
             *
             * If `target_value` is %NULL then the target value is unset.
             *
             * The target value has two purposes. First, it is used as the parameter
             * to activation of the action associated with the `GtkActionable` widget.
             * Second, it is used to determine if the widget should be rendered as
             * “active” — the widget is active if the state is equal to the given target.
             *
             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
             * with string state in a typical “radio button” situation. Each button
             * will be associated with the same action, but with a different target
             * value for that action. Clicking on a particular button will activate
             * the action with the target of that button, which will typically cause
             * the action’s state to change to that value. Since the action’s state
             * is now equal to the target value of the button, the button will now
             * be rendered as active (and the other buttons, with different targets,
             * rendered inactive).
             * @param target_value a [struct@GLib.Variant] to set as the target value
             */
            set_action_target_value(target_value?: GLib.Variant | null): void;
            /**
             * Sets the action-name and associated string target value of an
             * actionable widget.
             *
             * `detailed_action_name` is a string in the format accepted by
             * [func`Gio`.Action.parse_detailed_name].
             * @param detailed_action_name the detailed action name
             */
            set_detailed_action_name(detailed_action_name: string): void;
            /**
             * Gets the action name for `actionable`.
             */
            vfunc_get_action_name(): string | null;
            /**
             * Gets the current target value of `actionable`.
             */
            vfunc_get_action_target_value(): GLib.Variant | null;
            /**
             * Specifies the name of the action with which this widget should be
             * associated.
             *
             * If `action_name` is %NULL then the widget will be unassociated from
             * any previous action.
             *
             * Usually this function is used when the widget is located (or will be
             * located) within the hierarchy of a `GtkApplicationWindow`.
             *
             * Names are of the form “win.save” or “app.quit” for actions on the
             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
             * associated with the window.
             * @param action_name an action name
             */
            vfunc_set_action_name(action_name?: string | null): void;
            /**
             * Sets the target value of an actionable widget.
             *
             * If `target_value` is %NULL then the target value is unset.
             *
             * The target value has two purposes. First, it is used as the parameter
             * to activation of the action associated with the `GtkActionable` widget.
             * Second, it is used to determine if the widget should be rendered as
             * “active” — the widget is active if the state is equal to the given target.
             *
             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
             * with string state in a typical “radio button” situation. Each button
             * will be associated with the same action, but with a different target
             * value for that action. Clicking on a particular button will activate
             * the action with the target of that button, which will typically cause
             * the action’s state to change to that value. Since the action’s state
             * is now equal to the target value of the button, the button will now
             * be rendered as active (and the other buttons, with different targets,
             * rendered inactive).
             * @param target_value a [struct@GLib.Variant] to set as the target value
             */
            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace Text {
            // Signal callback interfaces

            interface Activate {
                (): void;
            }

            interface Backspace {
                (): void;
            }

            interface CopyClipboard {
                (): void;
            }

            interface CutClipboard {
                (): void;
            }

            interface DeleteFromCursor {
                (type: DeleteType, count: number): void;
            }

            interface InsertAtCursor {
                (string: string): void;
            }

            interface InsertEmoji {
                (): void;
            }

            interface MoveCursor {
                (step: MovementStep, count: number, extend: boolean): void;
            }

            interface PasteClipboard {
                (): void;
            }

            interface PreeditChanged {
                (preedit: string): void;
            }

            interface ToggleOverwrite {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    AccessibleText.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Editable.ConstructorProps {
                activates_default: boolean;
                activatesDefault: boolean;
                attributes: Pango.AttrList;
                buffer: EntryBuffer;
                enable_emoji_completion: boolean;
                enableEmojiCompletion: boolean;
                extra_menu: Gio.MenuModel;
                extraMenu: Gio.MenuModel;
                im_module: string;
                imModule: string;
                input_hints: InputHints;
                inputHints: InputHints;
                input_purpose: InputPurpose;
                inputPurpose: InputPurpose;
                invisible_char: number;
                invisibleChar: number;
                invisible_char_set: boolean;
                invisibleCharSet: boolean;
                max_length: number;
                maxLength: number;
                overwrite_mode: boolean;
                overwriteMode: boolean;
                placeholder_text: string;
                placeholderText: string;
                propagate_text_width: boolean;
                propagateTextWidth: boolean;
                scroll_offset: number;
                scrollOffset: number;
                tabs: Pango.TabArray;
                truncate_multiline: boolean;
                truncateMultiline: boolean;
                visibility: boolean;
            }
        }

        /**
         * The `GtkText` widget is a single-line text entry widget.
         *
         * `GtkText` is the common implementation of single-line text editing
         * that is shared between [class`Gtk`.Entry], [class`Gtk`.PasswordEntry],
         * [class`Gtk`.SpinButton], and other widgets. In all of these, `GtkText` is
         * used as the delegate for the [iface`Gtk`.Editable] implementation.
         *
         * A fairly large set of key bindings are supported by default. If the
         * entered text is longer than the allocation of the widget, the widget
         * will scroll so that the cursor position is visible.
         *
         * When using an entry for passwords and other sensitive information,
         * it can be put into “password mode” using [method`Gtk`.Text.set_visibility].
         * In this mode, entered text is displayed using a “invisible” character.
         * By default, GTK picks the best invisible character that is available
         * in the current font, but it can be changed with
         * [method`Gtk`.Text.set_invisible_char].
         *
         * If you are looking to add icons or progress display in an entry, look
         * at [class`Gtk`.Entry]. There other alternatives for more specialized use
         * cases, such as [class`Gtk`.SearchEntry].
         *
         * If you need multi-line editable text, look at [class`Gtk`.TextView].
         *
         * # Shortcuts and Gestures
         *
         * `GtkText` supports the following keyboard shortcuts:
         *
         * - <kbd>Shift</kbd>+<kbd>F10</kbd> or <kbd>Menu</kbd> opens the context menu.
         * - <kbd>Ctrl</kbd>+<kbd>A</kbd> or <kbd>Ctrl</kbd>+<kbd>&sol;</kbd>
         *   selects all the text.
         * - <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>A</kbd> or
         *   <kbd>Ctrl</kbd>+<kbd>&bsol;</kbd> unselects all.
         * - <kbd>Ctrl</kbd>+<kbd>Z</kbd> undoes the last modification.
         * - <kbd>Ctrl</kbd>+<kbd>Y</kbd> or <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Z</kbd>
         *   redoes the last undone modification.
         *
         * Additionally, the following signals have default keybindings:
         *
         * - [signal`Gtk`.Text::activate]
         * - [signal`Gtk`.Text::backspace]
         * - [signal`Gtk`.Text::copy-clipboard]
         * - [signal`Gtk`.Text::cut-clipboard]
         * - [signal`Gtk`.Text::delete-from-cursor]
         * - [signal`Gtk`.Text::insert-emoji]
         * - [signal`Gtk`.Text::move-cursor]
         * - [signal`Gtk`.Text::paste-clipboard]
         * - [signal`Gtk`.Text::toggle-overwrite]
         *
         * # Actions
         *
         * `GtkText` defines a set of built-in actions:
         *
         * - `clipboard.copy` copies the contents to the clipboard.
         * - `clipboard.cut` copies the contents to the clipboard and deletes it from
         *   the widget.
         * - `clipboard.paste` inserts the contents of the clipboard into the widget.
         * - `menu.popup` opens the context menu.
         * - `misc.insert-emoji` opens the Emoji chooser.
         * - `misc.toggle-visibility` toggles the `GtkText`:visibility property.
         * - `selection.delete` deletes the current selection.
         * - `selection.select-all` selects all of the widgets content.
         * - `text.redo` redoes the last change to the contents.
         * - `text.undo` undoes the last change to the contents.
         *
         * # CSS nodes
         *
         * ```
         * text[.read-only]
         * ├── placeholder
         * ├── undershoot.left
         * ├── undershoot.right
         * ├── [selection]
         * ├── [block-cursor]
         * ╰── [window.popup]
         * ```
         *
         * `GtkText` has a main node with the name `text`. Depending on the properties
         * of the widget, the `.read-only` style class may appear.
         *
         * When the entry has a selection, it adds a subnode with the name `selection`.
         *
         * When the entry is in overwrite mode, it adds a subnode with the name
         * `block-cursor` that determines how the block cursor is drawn.
         *
         * The CSS node for a context menu is added as a subnode with the name `popup`.
         *
         * The `undershoot` nodes are used to draw the underflow indication when content
         * is scrolled out of view. These nodes get the `.left` or `.right` style class
         * added depending on where the indication is drawn.
         *
         * When touch is used and touch selection handles are shown, they are using
         * CSS nodes with name `cursor-handle`. They get the `.top` or `.bottom` style
         * class depending on where they are shown in relation to the selection. If
         * there is just a single handle for the text cursor, it gets the style class
         * `.insertion-cursor`.
         *
         * # Accessibility
         *
         * `GtkText` uses the %GTK_ACCESSIBLE_ROLE_NONE role, which causes it to be
         * skipped for accessibility. This is because `GtkText` is expected to be used
         * as a delegate for a `GtkEditable` implementation that will be represented
         * to accessibility.
         */
        class Text extends Widget implements Accessible, AccessibleText, Buildable, ConstraintTarget, Editable {
            static $gtype: GObject.GType<Text>;

            // Properties

            /**
             * Whether to activate the default widget when Enter is pressed.
             */
            get activates_default(): boolean;
            set activates_default(val: boolean);
            /**
             * Whether to activate the default widget when Enter is pressed.
             */
            get activatesDefault(): boolean;
            set activatesDefault(val: boolean);
            /**
             * A list of Pango attributes to apply to the text of the `GtkText`.
             *
             * This is mainly useful to change the size or weight of the text.
             *
             * The `PangoAttribute`'s `start_index` and `end_index` must refer to the
             * `GtkEntryBuffer` text, i.e. without the preedit string.
             */
            get attributes(): Pango.AttrList;
            set attributes(val: Pango.AttrList);
            /**
             * The `GtkEntryBuffer` object which stores the text.
             */
            get buffer(): EntryBuffer;
            set buffer(val: EntryBuffer);
            /**
             * Whether to suggest Emoji replacements.
             */
            get enable_emoji_completion(): boolean;
            set enable_emoji_completion(val: boolean);
            /**
             * Whether to suggest Emoji replacements.
             */
            get enableEmojiCompletion(): boolean;
            set enableEmojiCompletion(val: boolean);
            /**
             * A menu model whose contents will be appended to
             * the context menu.
             */
            get extra_menu(): Gio.MenuModel;
            set extra_menu(val: Gio.MenuModel);
            /**
             * A menu model whose contents will be appended to
             * the context menu.
             */
            get extraMenu(): Gio.MenuModel;
            set extraMenu(val: Gio.MenuModel);
            /**
             * Which IM (input method) module should be used for this self.
             *
             * See [class`Gtk`.IMMulticontext].
             *
             * Setting this to a non-%NULL value overrides the system-wide
             * IM module setting. See the [property`Gtk`.Settings:gtk-im-module]
             * property.
             */
            get im_module(): string;
            set im_module(val: string);
            /**
             * Which IM (input method) module should be used for this self.
             *
             * See [class`Gtk`.IMMulticontext].
             *
             * Setting this to a non-%NULL value overrides the system-wide
             * IM module setting. See the [property`Gtk`.Settings:gtk-im-module]
             * property.
             */
            get imModule(): string;
            set imModule(val: string);
            /**
             * Additional hints that allow input methods to fine-tune
             * their behaviour.
             */
            get input_hints(): InputHints;
            set input_hints(val: InputHints);
            /**
             * Additional hints that allow input methods to fine-tune
             * their behaviour.
             */
            get inputHints(): InputHints;
            set inputHints(val: InputHints);
            /**
             * The purpose of this text field.
             *
             * This property can be used by on-screen keyboards and other input
             * methods to adjust their behaviour.
             *
             * Note that setting the purpose to %GTK_INPUT_PURPOSE_PASSWORD or
             * %GTK_INPUT_PURPOSE_PIN is independent from setting
             * [property`Gtk`.Text:visibility].
             */
            get input_purpose(): InputPurpose;
            set input_purpose(val: InputPurpose);
            /**
             * The purpose of this text field.
             *
             * This property can be used by on-screen keyboards and other input
             * methods to adjust their behaviour.
             *
             * Note that setting the purpose to %GTK_INPUT_PURPOSE_PASSWORD or
             * %GTK_INPUT_PURPOSE_PIN is independent from setting
             * [property`Gtk`.Text:visibility].
             */
            get inputPurpose(): InputPurpose;
            set inputPurpose(val: InputPurpose);
            /**
             * The character to used when masking contents (in “password mode”).
             */
            get invisible_char(): number;
            set invisible_char(val: number);
            /**
             * The character to used when masking contents (in “password mode”).
             */
            get invisibleChar(): number;
            set invisibleChar(val: number);
            /**
             * Whether the invisible char has been set for the `GtkText`.
             */
            get invisible_char_set(): boolean;
            set invisible_char_set(val: boolean);
            /**
             * Whether the invisible char has been set for the `GtkText`.
             */
            get invisibleCharSet(): boolean;
            set invisibleCharSet(val: boolean);
            /**
             * Maximum number of characters that are allowed.
             *
             * Zero indicates no limit.
             */
            get max_length(): number;
            set max_length(val: number);
            /**
             * Maximum number of characters that are allowed.
             *
             * Zero indicates no limit.
             */
            get maxLength(): number;
            set maxLength(val: number);
            /**
             * If text is overwritten when typing in the `GtkText`.
             */
            get overwrite_mode(): boolean;
            set overwrite_mode(val: boolean);
            /**
             * If text is overwritten when typing in the `GtkText`.
             */
            get overwriteMode(): boolean;
            set overwriteMode(val: boolean);
            /**
             * The text that will be displayed in the `GtkText` when it is empty
             * and unfocused.
             */
            get placeholder_text(): string;
            set placeholder_text(val: string);
            /**
             * The text that will be displayed in the `GtkText` when it is empty
             * and unfocused.
             */
            get placeholderText(): string;
            set placeholderText(val: string);
            /**
             * Whether the widget should grow and shrink with the content.
             */
            get propagate_text_width(): boolean;
            set propagate_text_width(val: boolean);
            /**
             * Whether the widget should grow and shrink with the content.
             */
            get propagateTextWidth(): boolean;
            set propagateTextWidth(val: boolean);
            /**
             * Number of pixels scrolled of the screen to the left.
             */
            get scroll_offset(): number;
            /**
             * Number of pixels scrolled of the screen to the left.
             */
            get scrollOffset(): number;
            /**
             * A list of tabstops to apply to the text of the `GtkText`.
             */
            get tabs(): Pango.TabArray;
            set tabs(val: Pango.TabArray);
            /**
             * When %TRUE, pasted multi-line text is truncated to the first line.
             */
            get truncate_multiline(): boolean;
            set truncate_multiline(val: boolean);
            /**
             * When %TRUE, pasted multi-line text is truncated to the first line.
             */
            get truncateMultiline(): boolean;
            set truncateMultiline(val: boolean);
            /**
             * If %FALSE, the text is masked with the “invisible char”.
             */
            get visibility(): boolean;
            set visibility(val: boolean);

            // Constructors

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

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

            static ['new'](): Text;

            static new_with_buffer(buffer: EntryBuffer): Text;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate', callback: (_source: this) => void): number;
            connect_after(signal: 'activate', callback: (_source: this) => void): number;
            emit(signal: 'activate'): void;
            connect(signal: 'backspace', callback: (_source: this) => void): number;
            connect_after(signal: 'backspace', callback: (_source: this) => void): number;
            emit(signal: 'backspace'): void;
            connect(signal: 'copy-clipboard', callback: (_source: this) => void): number;
            connect_after(signal: 'copy-clipboard', callback: (_source: this) => void): number;
            emit(signal: 'copy-clipboard'): void;
            connect(signal: 'cut-clipboard', callback: (_source: this) => void): number;
            connect_after(signal: 'cut-clipboard', callback: (_source: this) => void): number;
            emit(signal: 'cut-clipboard'): void;
            connect(
                signal: 'delete-from-cursor',
                callback: (_source: this, type: DeleteType, count: number) => void,
            ): number;
            connect_after(
                signal: 'delete-from-cursor',
                callback: (_source: this, type: DeleteType, count: number) => void,
            ): number;
            emit(signal: 'delete-from-cursor', type: DeleteType, count: number): void;
            connect(signal: 'insert-at-cursor', callback: (_source: this, string: string) => void): number;
            connect_after(signal: 'insert-at-cursor', callback: (_source: this, string: string) => void): number;
            emit(signal: 'insert-at-cursor', string: string): void;
            connect(signal: 'insert-emoji', callback: (_source: this) => void): number;
            connect_after(signal: 'insert-emoji', callback: (_source: this) => void): number;
            emit(signal: 'insert-emoji'): void;
            connect(
                signal: 'move-cursor',
                callback: (_source: this, step: MovementStep, count: number, extend: boolean) => void,
            ): number;
            connect_after(
                signal: 'move-cursor',
                callback: (_source: this, step: MovementStep, count: number, extend: boolean) => void,
            ): number;
            emit(signal: 'move-cursor', step: MovementStep, count: number, extend: boolean): void;
            connect(signal: 'paste-clipboard', callback: (_source: this) => void): number;
            connect_after(signal: 'paste-clipboard', callback: (_source: this) => void): number;
            emit(signal: 'paste-clipboard'): void;
            connect(signal: 'preedit-changed', callback: (_source: this, preedit: string) => void): number;
            connect_after(signal: 'preedit-changed', callback: (_source: this, preedit: string) => void): number;
            emit(signal: 'preedit-changed', preedit: string): void;
            connect(signal: 'toggle-overwrite', callback: (_source: this) => void): number;
            connect_after(signal: 'toggle-overwrite', callback: (_source: this) => void): number;
            emit(signal: 'toggle-overwrite'): void;

            // Methods

            /**
             * Determine the positions of the strong and weak cursors if the
             * insertion point in the layout is at `position`.
             *
             * The position of each cursor is stored as a zero-width rectangle.
             * The strong cursor location is the location where characters of
             * the directionality equal to the base direction are inserted.
             * The weak cursor location is the location where characters of
             * the directionality opposite to the base direction are inserted.
             *
             * The rectangle positions are in widget coordinates.
             * @param position the character position
             */
            compute_cursor_extents(position: number): [Graphene.Rect | null, Graphene.Rect | null];
            /**
             * Returns whether pressing Enter will activate
             * the default widget for the window containing `self`.
             *
             * See [method`Gtk`.Text.set_activates_default].
             * @returns %TRUE if the `GtkText` will activate the default widget
             */
            get_activates_default(): boolean;
            /**
             * Gets the attribute list that was set on the `GtkText`.
             *
             * See [method`Gtk`.Text.set_attributes].
             * @returns the attribute list
             */
            get_attributes(): Pango.AttrList | null;
            /**
             * Get the `GtkEntryBuffer` object which holds the text for
             * this widget.
             * @returns A `GtkEntryBuffer` object.
             */
            get_buffer(): EntryBuffer;
            /**
             * Returns whether Emoji completion is enabled for this
             * `GtkText` widget.
             * @returns %TRUE if Emoji completion is enabled
             */
            get_enable_emoji_completion(): boolean;
            /**
             * Gets the menu model for extra items in the context menu.
             *
             * See [method`Gtk`.Text.set_extra_menu].
             * @returns the menu model
             */
            get_extra_menu(): Gio.MenuModel | null;
            /**
             * Gets the input hints of the `GtkText`.
             * @returns the input hints
             */
            get_input_hints(): InputHints;
            /**
             * Gets the input purpose of the `GtkText`.
             * @returns the input purpose
             */
            get_input_purpose(): InputPurpose;
            /**
             * Retrieves the character displayed when visibility is set to false.
             *
             * Note that GTK does not compute this value unless it needs it,
             * so the value returned by this function is not very useful unless
             * it has been explicitly set with [method`Gtk`.Text.set_invisible_char].
             * @returns the current invisible char, or 0, if @text does not   show invisible text at all.
             */
            get_invisible_char(): number;
            /**
             * Retrieves the maximum allowed length of the text in `self`.
             *
             * See [method`Gtk`.Text.set_max_length].
             *
             * This is equivalent to getting `self'`s `GtkEntryBuffer` and
             * calling [method`Gtk`.EntryBuffer.get_max_length] on it.
             * @returns the maximum allowed number of characters   in `GtkText`, or 0 if there is no maximum.
             */
            get_max_length(): number;
            /**
             * Gets whether text is overwritten when typing in the `GtkText`.
             *
             * See [method`Gtk`.Text.set_overwrite_mode].
             * @returns whether the text is overwritten when typing
             */
            get_overwrite_mode(): boolean;
            /**
             * Retrieves the text that will be displayed when
             * `self` is empty and unfocused
             *
             * If no placeholder text has been set, %NULL will be returned.
             * @returns the placeholder text
             */
            get_placeholder_text(): string | null;
            /**
             * Returns whether the `GtkText` will grow and shrink
             * with the content.
             * @returns %TRUE if @self will propagate the text width
             */
            get_propagate_text_width(): boolean;
            /**
             * Gets the tabstops that were set on the `GtkText`.
             *
             * See [method`Gtk`.Text.set_tabs].
             * @returns the tabstops
             */
            get_tabs(): Pango.TabArray | null;
            /**
             * Retrieves the current length of the text in `self`.
             *
             * This is equivalent to getting `self'`s `GtkEntryBuffer`
             * and calling [method`Gtk`.EntryBuffer.get_length] on it.
             * @returns the current number of characters   in `GtkText`, or 0 if there are none.
             */
            get_text_length(): number;
            /**
             * Returns whether the `GtkText` will truncate multi-line text
             * that is pasted into the widget
             * @returns %TRUE if @self will truncate multi-line text
             */
            get_truncate_multiline(): boolean;
            /**
             * Retrieves whether the text in `self` is visible.
             * @returns %TRUE if the text is currently visible
             */
            get_visibility(): boolean;
            /**
             * Causes `self` to have keyboard focus.
             *
             * It behaves like [method`Gtk`.Widget.grab_focus],
             * except that it doesn't select the contents of `self`.
             * You only want to call this on some special entries
             * which the user usually doesn't want to replace all text in,
             * such as search-as-you-type entries.
             * @returns %TRUE if focus is now inside @self
             */
            grab_focus_without_selecting(): boolean;
            /**
             * If `activates` is %TRUE, pressing Enter will activate
             * the default widget for the window containing `self`.
             *
             * This usually means that the dialog containing the `GtkText`
             * will be closed, since the default widget is usually one of
             * the dialog buttons.
             * @param activates %TRUE to activate window’s default widget on Enter keypress
             */
            set_activates_default(activates: boolean): void;
            /**
             * Sets attributes that are applied to the text.
             * @param attrs a `PangoAttrList`
             */
            set_attributes(attrs?: Pango.AttrList | null): void;
            /**
             * Set the `GtkEntryBuffer` object which holds the text for
             * this widget.
             * @param buffer a `GtkEntryBuffer`
             */
            set_buffer(buffer: EntryBuffer): void;
            /**
             * Sets whether Emoji completion is enabled.
             *
             * If it is, typing ':', followed by a recognized keyword,
             * will pop up a window with suggested Emojis matching the
             * keyword.
             * @param enable_emoji_completion %TRUE to enable Emoji completion
             */
            set_enable_emoji_completion(enable_emoji_completion: boolean): void;
            /**
             * Sets a menu model to add when constructing
             * the context menu for `self`.
             * @param model a `GMenuModel`
             */
            set_extra_menu(model?: Gio.MenuModel | null): void;
            /**
             * Sets input hints that allow input methods
             * to fine-tune their behaviour.
             * @param hints the hints
             */
            set_input_hints(hints: InputHints | null): void;
            /**
             * Sets the input purpose of the `GtkText`.
             *
             * This can be used by on-screen keyboards and other
             * input methods to adjust their behaviour.
             * @param purpose the purpose
             */
            set_input_purpose(purpose: InputPurpose | null): void;
            /**
             * Sets the character to use when in “password mode”.
             *
             * By default, GTK picks the best invisible char available in the
             * current font. If you set the invisible char to 0, then the user
             * will get no feedback at all; there will be no text on the screen
             * as they type.
             * @param ch a Unicode character
             */
            set_invisible_char(ch: number): void;
            /**
             * Sets the maximum allowed length of the contents of the widget.
             *
             * If the current contents are longer than the given length, then
             * they will be truncated to fit.
             *
             * This is equivalent to getting `self'`s `GtkEntryBuffer` and
             * calling [method`Gtk`.EntryBuffer.set_max_length] on it.
             * @param length the maximum length of the `GtkText`, or 0 for no maximum.   (other than the maximum length of entries.) The value passed   in will be clamped to the range 0-65536.
             */
            set_max_length(length: number): void;
            /**
             * Sets whether the text is overwritten when typing
             * in the `GtkText`.
             * @param overwrite new value
             */
            set_overwrite_mode(overwrite: boolean): void;
            /**
             * Sets text to be displayed in `self` when it is empty.
             *
             * This can be used to give a visual hint of the expected
             * contents of the `GtkText`.
             * @param text a string to be displayed when @self   is empty and unfocused
             */
            set_placeholder_text(text?: string | null): void;
            /**
             * Sets whether the `GtkText` should grow and shrink with the content.
             * @param propagate_text_width %TRUE to propagate the text width
             */
            set_propagate_text_width(propagate_text_width: boolean): void;
            /**
             * Sets tabstops that are applied to the text.
             * @param tabs a `PangoTabArray`
             */
            set_tabs(tabs?: Pango.TabArray | null): void;
            /**
             * Sets whether the `GtkText` should truncate multi-line text
             * that is pasted into the widget.
             * @param truncate_multiline %TRUE to truncate multi-line text
             */
            set_truncate_multiline(truncate_multiline: boolean): void;
            /**
             * Sets whether the contents of the `GtkText` are visible or not.
             *
             * When visibility is set to %FALSE, characters are displayed
             * as the invisible char, and will also appear that way when
             * the text in the widget is copied to the clipboard.
             *
             * By default, GTK picks the best invisible character available
             * in the current font, but it can be changed with
             * [method`Gtk`.Text.set_invisible_char].
             *
             * Note that you probably want to set [property`Gtk`.Text:input-purpose]
             * to %GTK_INPUT_PURPOSE_PASSWORD or %GTK_INPUT_PURPOSE_PIN to
             * inform input methods about the purpose of this self,
             * in addition to setting visibility to %FALSE.
             * @param visible %TRUE if the contents of the `GtkText` are displayed   as plaintext
             */
            set_visibility(visible: boolean): void;
            /**
             * Unsets the invisible char.
             *
             * After calling this, the default invisible
             * char is used again.
             */
            unset_invisible_char(): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * The current position of the insertion cursor in chars.
             */
            get cursor_position(): number;
            /**
             * The current position of the insertion cursor in chars.
             */
            get cursorPosition(): number;
            /**
             * Whether the entry contents can be edited.
             */
            get editable(): boolean;
            set editable(val: boolean);
            /**
             * If undo/redo should be enabled for the editable.
             */
            get enable_undo(): boolean;
            set enable_undo(val: boolean);
            /**
             * If undo/redo should be enabled for the editable.
             */
            get enableUndo(): boolean;
            set enableUndo(val: boolean);
            /**
             * The desired maximum width of the entry, in characters.
             */
            get max_width_chars(): number;
            set max_width_chars(val: number);
            /**
             * The desired maximum width of the entry, in characters.
             */
            get maxWidthChars(): number;
            set maxWidthChars(val: number);
            /**
             * The position of the opposite end of the selection from the cursor in chars.
             */
            get selection_bound(): number;
            /**
             * The position of the opposite end of the selection from the cursor in chars.
             */
            get selectionBound(): number;
            /**
             * The contents of the entry.
             */
            get text(): string;
            set text(val: string);
            /**
             * Number of characters to leave space for in the entry.
             */
            get width_chars(): number;
            set width_chars(val: number);
            /**
             * Number of characters to leave space for in the entry.
             */
            get widthChars(): number;
            set widthChars(val: number);
            /**
             * The horizontal alignment, from 0 (left) to 1 (right).
             *
             * Reversed for RTL layouts.
             */
            get xalign(): number;
            set xalign(val: number);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Updates the position of the caret.
             *
             * Implementations of the `GtkAccessibleText` interface should call this
             * function every time the caret has moved, in order to notify assistive
             * technologies.
             */
            update_caret_position(): void;
            /**
             * Notifies assistive technologies of a change in contents.
             *
             * Implementations of the `GtkAccessibleText` interface should call this
             * function every time their contents change as the result of an operation,
             * like an insertion or a removal.
             *
             * Note: If the change is a deletion, this function must be called *before*
             * removing the contents, if it is an insertion, it must be called *after*
             * inserting the new contents.
             * @param change the type of change in the contents
             * @param start the starting offset of the change, in characters
             * @param end the end offset of the change, in characters
             */
            update_contents(change: AccessibleTextContentChange | null, start: number, end: number): void;
            /**
             * Updates the boundary of the selection.
             *
             * Implementations of the `GtkAccessibleText` interface should call this
             * function every time the selection has moved, in order to notify assistive
             * technologies.
             */
            update_selection_bound(): void;
            /**
             * Retrieves the text attributes inside the accessible object.
             *
             * Each attribute is composed by:
             *
             * - a range
             * - a name
             * - a value
             *
             * It is left to the implementation to determine the serialization format
             * of the value to a string.
             *
             * GTK provides support for various text attribute names and values, but
             * implementations of this interface are free to add their own attributes.
             *
             * If this function returns true, `n_ranges` will be set to a value
             * greater than or equal to one, `ranges` will be set to a newly
             * allocated array of [struct#Gtk.AccessibleTextRange].
             * @param offset the offset, in characters
             */
            vfunc_get_attributes(
                offset: number,
            ): [boolean, AccessibleTextRange[] | null, string[] | null, string[] | null];
            /**
             * Retrieves the position of the caret inside the accessible object.
             */
            vfunc_get_caret_position(): number;
            /**
             * Retrieve the current contents of the accessible object within
             * the given range.
             *
             * If `end` is `G_MAXUINT`, the end of the range is the full content
             * of the accessible object.
             * @param start the beginning of the range, in characters
             * @param end the end of the range, in characters
             */
            vfunc_get_contents(start: number, end: number): GLib.Bytes;
            /**
             * Retrieve the current contents of the accessible object starting
             * from the given offset, and using the given granularity.
             *
             * The `start` and `end` values contain the boundaries of the text.
             * @param offset the offset, in characters
             * @param granularity the granularity of the query
             */
            vfunc_get_contents_at(offset: number, granularity: AccessibleTextGranularity): [GLib.Bytes, number, number];
            /**
             * Retrieves the default text attributes inside the accessible object.
             *
             * Each attribute is composed by:
             *
             * - a name
             * - a value
             *
             * It is left to the implementation to determine the serialization format
             * of the value to a string.
             *
             * GTK provides support for various text attribute names and values, but
             * implementations of this interface are free to add their own attributes.
             */
            vfunc_get_default_attributes(): [string[] | null, string[] | null];
            /**
             * Obtains the extents of a range of text, in widget coordinates.
             * @param start the start offset, in characters
             * @param end the end offset, in characters, @extents (out caller-allocates): return location for the extents
             * @param extents
             */
            vfunc_get_extents(start: number, end: number, extents: Graphene.Rect): boolean;
            /**
             * Gets the text offset at a given point.
             * @param point a point in widget coordinates of @self
             */
            vfunc_get_offset(point: Graphene.Point): [boolean, number];
            /**
             * Retrieves the selection ranges in the accessible object.
             *
             * If this function returns true, `n_ranges` will be set to a value
             * greater than or equal to one, and `ranges` will be set to a newly
             * allocated array of [struct#Gtk.AccessibleTextRange].
             */
            vfunc_get_selection(): [boolean, AccessibleTextRange[] | null];
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Retrieves the accessible platform state from the editable delegate.
             *
             * This is an helper function to retrieve the accessible state for
             * `GtkEditable` interface implementations using a delegate pattern.
             *
             * You should call this function in your editable widget implementation
             * of the [vfunc`Gtk`.Accessible.get_platform_state] virtual function, for
             * instance:
             *
             * ```c
             * static void
             * accessible_interface_init (GtkAccessibleInterface *iface)
             * {
             *   iface->get_platform_state = your_editable_get_accessible_platform_state;
             * }
             *
             * static gboolean
             * your_editable_get_accessible_platform_state (GtkAccessible *accessible,
             *                                              GtkAccessiblePlatformState state)
             * {
             *   return gtk_editable_delegate_get_accessible_platform_state (GTK_EDITABLE (accessible), state);
             * }
             * ```
             *
             * Note that the widget which is the delegate *must* be a direct child of
             * this widget, otherwise your implementation of [vfunc`Gtk`.Accessible.get_platform_state]
             * might not even be called, as the platform change will originate from
             * the parent of the delegate, and, as a result, will not work properly.
             *
             * So, if you can't ensure the direct child condition, you should give the
             * delegate the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role, or you can
             * change your tree to allow this function to work.
             * @param state what kind of accessible state to retrieve
             * @returns the accessible platform state of the delegate
             */
            delegate_get_accessible_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Deletes the currently selected text of the editable.
             *
             * This call doesn’t do anything if there is no selected text.
             */
            delete_selection(): void;
            /**
             * Deletes a sequence of characters.
             *
             * The characters that are deleted are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters deleted are those from `start_pos` to
             * the end of the text.
             *
             * Note that the positions are specified in characters, not bytes.
             * @param start_pos start position
             * @param end_pos end position
             */
            delete_text(start_pos: number, end_pos: number): void;
            /**
             * Undoes the setup done by [method`Gtk`.Editable.init_delegate].
             *
             * This is a helper function that should be called from dispose,
             * before removing the delegate object.
             */
            finish_delegate(): void;
            /**
             * Gets the alignment of the editable.
             * @returns the alignment
             */
            get_alignment(): number;
            /**
             * Retrieves a sequence of characters.
             *
             * The characters that are retrieved are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is negative,
             * then the characters retrieved are those characters from `start_pos` to
             * the end of the text.
             *
             * Note that positions are specified in characters, not bytes.
             * @param start_pos start of text
             * @param end_pos end of text
             * @returns a pointer to the contents of the widget as a   string. This string is allocated by the `GtkEditable` implementation   and should be freed by the caller.
             */
            get_chars(start_pos: number, end_pos: number): string;
            /**
             * Gets the `GtkEditable` that `editable` is delegating its
             * implementation to.
             *
             * Typically, the delegate is a [class`Gtk`.Text] widget.
             * @returns the delegate `GtkEditable`
             */
            get_delegate(): Editable | null;
            /**
             * Retrieves whether `editable` is editable.
             * @returns %TRUE if @editable is editable.
             */
            get_editable(): boolean;
            /**
             * Gets if undo/redo actions are enabled for `editable`
             * @returns %TRUE if undo is enabled
             */
            get_enable_undo(): boolean;
            /**
             * Retrieves the desired maximum width of `editable,` in characters.
             * @returns the maximum width of the entry, in characters
             */
            get_max_width_chars(): number;
            /**
             * Retrieves the current position of the cursor relative
             * to the start of the content of the editable.
             *
             * Note that this position is in characters, not in bytes.
             * @returns the cursor position
             */
            get_position(): number;
            /**
             * Retrieves the selection bound of the editable.
             *
             * `start_pos` will be filled with the start of the selection and
             * `end_pos` with end. If no text was selected both will be identical
             * and %FALSE will be returned.
             *
             * Note that positions are specified in characters, not bytes.
             * @returns %TRUE if there is a non-empty selection, %FALSE otherwise
             */
            get_selection_bounds(): [boolean, number, number];
            /**
             * Retrieves the contents of `editable`.
             *
             * The returned string is owned by GTK and must not be modified or freed.
             * @returns a pointer to the contents of the editable
             */
            get_text(): string;
            /**
             * Gets the number of characters of space reserved
             * for the contents of the editable.
             * @returns number of chars to request space for, or negative if unset
             */
            get_width_chars(): number;
            /**
             * Sets up a delegate for `GtkEditable`.
             *
             * This is assuming that the get_delegate vfunc in the `GtkEditable`
             * interface has been set up for the `editable'`s type.
             *
             * This is a helper function that should be called in instance init,
             * after creating the delegate object.
             */
            init_delegate(): void;
            /**
             * Inserts `length` bytes of `text` into the contents of the
             * widget, at position `position`.
             *
             * Note that the position is in characters, not in bytes.
             * The function updates `position` to point after the newly
             * inserted text.
             * @param text the text to insert
             * @param length the length of the text in bytes, or -1
             * @param position location of the position text will be inserted at
             */
            insert_text(text: string, length: number, position: number): number;
            /**
             * Selects a region of text.
             *
             * The characters that are selected are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters selected are those characters from
             * `start_pos` to  the end of the text.
             *
             * Note that positions are specified in characters, not bytes.
             * @param start_pos start of region
             * @param end_pos end of region
             */
            select_region(start_pos: number, end_pos: number): void;
            /**
             * Sets the alignment for the contents of the editable.
             *
             * This controls the horizontal positioning of the contents when
             * the displayed text is shorter than the width of the editable.
             * @param xalign The horizontal alignment, from 0 (left) to 1 (right).   Reversed for RTL layouts
             */
            set_alignment(xalign: number): void;
            /**
             * Determines if the user can edit the text in the editable widget.
             * @param is_editable %TRUE if the user is allowed to edit the text   in the widget
             */
            set_editable(is_editable: boolean): void;
            /**
             * If enabled, changes to `editable` will be saved for undo/redo
             * actions.
             *
             * This results in an additional copy of text changes and are not
             * stored in secure memory. As such, undo is forcefully disabled
             * when [property`Gtk`.Text:visibility] is set to %FALSE.
             * @param enable_undo if undo/redo should be enabled
             */
            set_enable_undo(enable_undo: boolean): void;
            /**
             * Sets the desired maximum width in characters of `editable`.
             * @param n_chars the new desired maximum width, in characters
             */
            set_max_width_chars(n_chars: number): void;
            /**
             * Sets the cursor position in the editable to the given value.
             *
             * The cursor is displayed before the character with the given (base 0)
             * index in the contents of the editable. The value must be less than
             * or equal to the number of characters in the editable. A value of -1
             * indicates that the position should be set after the last character
             * of the editable. Note that `position` is in characters, not in bytes.
             * @param position the position of the cursor
             */
            set_position(position: number): void;
            /**
             * Sets the text in the editable to the given value.
             *
             * This is replacing the current contents.
             * @param text the text to set
             */
            set_text(text: string): void;
            /**
             * Changes the size request of the editable to be about the
             * right size for `n_chars` characters.
             *
             * Note that it changes the size request, the size can still
             * be affected by how you pack the widget into containers.
             * If `n_chars` is -1, the size reverts to the default size.
             * @param n_chars width in chars
             */
            set_width_chars(n_chars: number): void;
            vfunc_changed(): void;
            /**
             * Deletes a sequence of characters.
             *
             * The characters that are deleted are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters deleted are those from `start_pos` to
             * the end of the text.
             *
             * Note that the positions are specified in characters, not bytes.
             * @param start_pos start position
             * @param end_pos end position
             */
            vfunc_delete_text(start_pos: number, end_pos: number): void;
            /**
             * Deletes a sequence of characters.
             *
             * The characters that are deleted are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters deleted are those from `start_pos` to
             * the end of the text.
             *
             * Note that the positions are specified in characters, not bytes.
             * @param start_pos start position
             * @param end_pos end position
             */
            vfunc_do_delete_text(start_pos: number, end_pos: number): void;
            /**
             * Inserts `length` bytes of `text` into the contents of the
             * widget, at position `position`.
             *
             * Note that the position is in characters, not in bytes.
             * The function updates `position` to point after the newly
             * inserted text.
             * @param text the text to insert
             * @param length the length of the text in bytes, or -1
             * @param position location of the position text will be inserted at
             */
            vfunc_do_insert_text(text: string, length: number, position: number): number;
            /**
             * Gets the `GtkEditable` that `editable` is delegating its
             * implementation to.
             *
             * Typically, the delegate is a [class`Gtk`.Text] widget.
             */
            vfunc_get_delegate(): Editable | null;
            /**
             * Retrieves the selection bound of the editable.
             *
             * `start_pos` will be filled with the start of the selection and
             * `end_pos` with end. If no text was selected both will be identical
             * and %FALSE will be returned.
             *
             * Note that positions are specified in characters, not bytes.
             */
            vfunc_get_selection_bounds(): [boolean, number, number];
            /**
             * Retrieves the contents of `editable`.
             *
             * The returned string is owned by GTK and must not be modified or freed.
             */
            vfunc_get_text(): string;
            /**
             * Inserts `length` bytes of `text` into the contents of the
             * widget, at position `position`.
             *
             * Note that the position is in characters, not in bytes.
             * The function updates `position` to point after the newly
             * inserted text.
             * @param text the text to insert
             * @param length the length of the text in bytes, or -1
             * @param position location of the position text will be inserted at
             */
            vfunc_insert_text(text: string, length: number, position: number): number;
            /**
             * Selects a region of text.
             *
             * The characters that are selected are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters selected are those characters from
             * `start_pos` to  the end of the text.
             *
             * Note that positions are specified in characters, not bytes.
             * @param start_pos start of region
             * @param end_pos end of region
             */
            vfunc_set_selection_bounds(start_pos: number, end_pos: number): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace TextBuffer {
            // Signal callback interfaces

            interface ApplyTag {
                (tag: TextTag, start: TextIter, end: TextIter): void;
            }

            interface BeginUserAction {
                (): void;
            }

            interface Changed {
                (): void;
            }

            interface DeleteRange {
                (start: TextIter, end: TextIter): void;
            }

            interface EndUserAction {
                (): void;
            }

            interface InsertChildAnchor {
                (location: TextIter, anchor: TextChildAnchor): void;
            }

            interface InsertPaintable {
                (location: TextIter, paintable: Gdk.Paintable): void;
            }

            interface InsertText {
                (location: TextIter, text: string, len: number): void;
            }

            interface MarkDeleted {
                (mark: TextMark): void;
            }

            interface MarkSet {
                (location: TextIter, mark: TextMark): void;
            }

            interface ModifiedChanged {
                (): void;
            }

            interface PasteDone {
                (clipboard: Gdk.Clipboard): void;
            }

            interface Redo {
                (): void;
            }

            interface RemoveTag {
                (tag: TextTag, start: TextIter, end: TextIter): void;
            }

            interface Undo {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                can_redo: boolean;
                canRedo: boolean;
                can_undo: boolean;
                canUndo: boolean;
                cursor_position: number;
                cursorPosition: number;
                enable_undo: boolean;
                enableUndo: boolean;
                has_selection: boolean;
                hasSelection: boolean;
                tag_table: TextTagTable;
                tagTable: TextTagTable;
                text: string;
            }
        }

        /**
         * Stores text and attributes for display in a `GtkTextView`.
         *
         * You may wish to begin by reading the
         * [text widget conceptual overview](section-text-widget.html),
         * which gives an overview of all the objects and data types
         * related to the text widget and how they work together.
         *
         * GtkTextBuffer can support undoing changes to the buffer
         * content, see [method`Gtk`.TextBuffer.set_enable_undo].
         */
        class TextBuffer extends GObject.Object {
            static $gtype: GObject.GType<TextBuffer>;

            // Properties

            /**
             * Denotes that the buffer can reapply the last undone action.
             */
            get can_redo(): boolean;
            /**
             * Denotes that the buffer can reapply the last undone action.
             */
            get canRedo(): boolean;
            /**
             * Denotes that the buffer can undo the last applied action.
             */
            get can_undo(): boolean;
            /**
             * Denotes that the buffer can undo the last applied action.
             */
            get canUndo(): boolean;
            /**
             * The position of the insert mark.
             *
             * This is an offset from the beginning of the buffer.
             * It is useful for getting notified when the cursor moves.
             */
            get cursor_position(): number;
            /**
             * The position of the insert mark.
             *
             * This is an offset from the beginning of the buffer.
             * It is useful for getting notified when the cursor moves.
             */
            get cursorPosition(): number;
            /**
             * Denotes if support for undoing and redoing changes to the buffer is allowed.
             */
            get enable_undo(): boolean;
            set enable_undo(val: boolean);
            /**
             * Denotes if support for undoing and redoing changes to the buffer is allowed.
             */
            get enableUndo(): boolean;
            set enableUndo(val: boolean);
            /**
             * Whether the buffer has some text currently selected.
             */
            get has_selection(): boolean;
            /**
             * Whether the buffer has some text currently selected.
             */
            get hasSelection(): boolean;
            /**
             * The GtkTextTagTable for the buffer.
             */
            get tag_table(): TextTagTable;
            /**
             * The GtkTextTagTable for the buffer.
             */
            get tagTable(): TextTagTable;
            /**
             * The text content of the buffer.
             *
             * Without child widgets and images,
             * see [method`Gtk`.TextBuffer.get_text] for more information.
             */
            get text(): string;
            set text(val: string);

            // Constructors

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

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

            static ['new'](table?: TextTagTable | null): TextBuffer;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(
                signal: 'apply-tag',
                callback: (_source: this, tag: TextTag, start: TextIter, end: TextIter) => void,
            ): number;
            connect_after(
                signal: 'apply-tag',
                callback: (_source: this, tag: TextTag, start: TextIter, end: TextIter) => void,
            ): number;
            emit(signal: 'apply-tag', tag: TextTag, start: TextIter, end: TextIter): void;
            connect(signal: 'begin-user-action', callback: (_source: this) => void): number;
            connect_after(signal: 'begin-user-action', callback: (_source: this) => void): number;
            emit(signal: 'begin-user-action'): void;
            connect(signal: 'changed', callback: (_source: this) => void): number;
            connect_after(signal: 'changed', callback: (_source: this) => void): number;
            emit(signal: 'changed'): void;
            connect(signal: 'delete-range', callback: (_source: this, start: TextIter, end: TextIter) => void): number;
            connect_after(
                signal: 'delete-range',
                callback: (_source: this, start: TextIter, end: TextIter) => void,
            ): number;
            emit(signal: 'delete-range', start: TextIter, end: TextIter): void;
            connect(signal: 'end-user-action', callback: (_source: this) => void): number;
            connect_after(signal: 'end-user-action', callback: (_source: this) => void): number;
            emit(signal: 'end-user-action'): void;
            connect(
                signal: 'insert-child-anchor',
                callback: (_source: this, location: TextIter, anchor: TextChildAnchor) => void,
            ): number;
            connect_after(
                signal: 'insert-child-anchor',
                callback: (_source: this, location: TextIter, anchor: TextChildAnchor) => void,
            ): number;
            emit(signal: 'insert-child-anchor', location: TextIter, anchor: TextChildAnchor): void;
            connect(
                signal: 'insert-paintable',
                callback: (_source: this, location: TextIter, paintable: Gdk.Paintable) => void,
            ): number;
            connect_after(
                signal: 'insert-paintable',
                callback: (_source: this, location: TextIter, paintable: Gdk.Paintable) => void,
            ): number;
            emit(signal: 'insert-paintable', location: TextIter, paintable: Gdk.Paintable): void;
            connect(
                signal: 'insert-text',
                callback: (_source: this, location: TextIter, text: string, len: number) => void,
            ): number;
            connect_after(
                signal: 'insert-text',
                callback: (_source: this, location: TextIter, text: string, len: number) => void,
            ): number;
            emit(signal: 'insert-text', location: TextIter, text: string, len: number): void;
            connect(signal: 'mark-deleted', callback: (_source: this, mark: TextMark) => void): number;
            connect_after(signal: 'mark-deleted', callback: (_source: this, mark: TextMark) => void): number;
            emit(signal: 'mark-deleted', mark: TextMark): void;
            connect(signal: 'mark-set', callback: (_source: this, location: TextIter, mark: TextMark) => void): number;
            connect_after(
                signal: 'mark-set',
                callback: (_source: this, location: TextIter, mark: TextMark) => void,
            ): number;
            emit(signal: 'mark-set', location: TextIter, mark: TextMark): void;
            connect(signal: 'modified-changed', callback: (_source: this) => void): number;
            connect_after(signal: 'modified-changed', callback: (_source: this) => void): number;
            emit(signal: 'modified-changed'): void;
            connect(signal: 'paste-done', callback: (_source: this, clipboard: Gdk.Clipboard) => void): number;
            connect_after(signal: 'paste-done', callback: (_source: this, clipboard: Gdk.Clipboard) => void): number;
            emit(signal: 'paste-done', clipboard: Gdk.Clipboard): void;
            connect(signal: 'redo', callback: (_source: this) => void): number;
            connect_after(signal: 'redo', callback: (_source: this) => void): number;
            emit(signal: 'redo'): void;
            connect(
                signal: 'remove-tag',
                callback: (_source: this, tag: TextTag, start: TextIter, end: TextIter) => void,
            ): number;
            connect_after(
                signal: 'remove-tag',
                callback: (_source: this, tag: TextTag, start: TextIter, end: TextIter) => void,
            ): number;
            emit(signal: 'remove-tag', tag: TextTag, start: TextIter, end: TextIter): void;
            connect(signal: 'undo', callback: (_source: this) => void): number;
            connect_after(signal: 'undo', callback: (_source: this) => void): number;
            emit(signal: 'undo'): void;

            // Virtual methods

            /**
             * Emits the “apply-tag” signal on `buffer`.
             *
             * The default handler for the signal applies
             * `tag` to the given range. `start` and `end` do
             * not have to be in order.
             * @param tag a `GtkTextTag`
             * @param start one bound of range to be tagged
             * @param end other bound of range to be tagged
             */
            vfunc_apply_tag(tag: TextTag, start: TextIter, end: TextIter): void;
            /**
             * Called to indicate that the buffer operations between here and a
             * call to gtk_text_buffer_end_user_action() are part of a single
             * user-visible operation.
             *
             * The operations between gtk_text_buffer_begin_user_action() and
             * gtk_text_buffer_end_user_action() can then be grouped when creating
             * an undo stack. `GtkTextBuffer` maintains a count of calls to
             * gtk_text_buffer_begin_user_action() that have not been closed with
             * a call to gtk_text_buffer_end_user_action(), and emits the
             * “begin-user-action” and “end-user-action” signals only for the
             * outermost pair of calls. This allows you to build user actions
             * from other user actions.
             *
             * The “interactive” buffer mutation functions, such as
             * [method`Gtk`.TextBuffer.insert_interactive], automatically call
             * begin/end user action around the buffer operations they perform,
             * so there's no need to add extra calls if you user action consists
             * solely of a single call to one of those functions.
             */
            vfunc_begin_user_action(): void;
            /**
             * The class handler for the `GtkTextBuffer::changed` signal.
             */
            vfunc_changed(): void;
            /**
             * The class handler for the `GtkTextBuffer::delete-range` signal.
             * @param start
             * @param end
             */
            vfunc_delete_range(start: TextIter, end: TextIter): void;
            /**
             * Ends a user-visible operation.
             *
             * Should be paired with a call to
             * [method`Gtk`.TextBuffer.begin_user_action].
             * See that function for a full explanation.
             */
            vfunc_end_user_action(): void;
            /**
             * Inserts a child widget anchor into the text buffer at `iter`.
             *
             * The anchor will be counted as one character in character counts, and
             * when obtaining the buffer contents as a string, will be represented
             * by the Unicode “object replacement character” 0xFFFC. Note that the
             * “slice” variants for obtaining portions of the buffer as a string
             * include this character for child anchors, but the “text” variants do
             * not. E.g. see [method`Gtk`.TextBuffer.get_slice] and
             * [method`Gtk`.TextBuffer.get_text].
             *
             * Consider [method`Gtk`.TextBuffer.create_child_anchor] as a more
             * convenient alternative to this function. The buffer will add a
             * reference to the anchor, so you can unref it after insertion.
             * @param iter location to insert the anchor
             * @param anchor a `GtkTextChildAnchor`
             */
            vfunc_insert_child_anchor(iter: TextIter, anchor: TextChildAnchor): void;
            /**
             * Inserts an image into the text buffer at `iter`.
             *
             * The image will be counted as one character in character counts,
             * and when obtaining the buffer contents as a string, will be
             * represented by the Unicode “object replacement character” 0xFFFC.
             * Note that the “slice” variants for obtaining portions of the buffer
             * as a string include this character for paintable, but the “text”
             * variants do not. e.g. see [method`Gtk`.TextBuffer.get_slice] and
             * [method`Gtk`.TextBuffer.get_text].
             * @param iter location to insert the paintable
             * @param paintable a `GdkPaintable`
             */
            vfunc_insert_paintable(iter: TextIter, paintable: Gdk.Paintable): void;
            /**
             * The class handler for the `GtkTextBuffer::insert-text` signal.
             * @param pos
             * @param new_text
             * @param new_text_length
             */
            vfunc_insert_text(pos: TextIter, new_text: string, new_text_length: number): void;
            /**
             * The class handler for the `GtkTextBuffer::mark-deleted` signal.
             * @param mark
             */
            vfunc_mark_deleted(mark: TextMark): void;
            /**
             * The class handler for the `GtkTextBuffer::mark-set` signal.
             * @param location
             * @param mark
             */
            vfunc_mark_set(location: TextIter, mark: TextMark): void;
            /**
             * The class handler for the `GtkTextBuffer::modified-changed` signal.
             */
            vfunc_modified_changed(): void;
            /**
             * The class handler for the `GtkTextBuffer::paste-done` signal.
             * @param clipboard
             */
            vfunc_paste_done(clipboard: Gdk.Clipboard): void;
            /**
             * Redoes the next redoable action on the buffer, if there is one.
             */
            vfunc_redo(): void;
            /**
             * Emits the “remove-tag” signal.
             *
             * The default handler for the signal removes all occurrences
             * of `tag` from the given range. `start` and `end` don’t have
             * to be in order.
             * @param tag a `GtkTextTag`
             * @param start one bound of range to be untagged
             * @param end other bound of range to be untagged
             */
            vfunc_remove_tag(tag: TextTag, start: TextIter, end: TextIter): void;
            /**
             * Undoes the last undoable action on the buffer, if there is one.
             */
            vfunc_undo(): void;

            // Methods

            /**
             * Adds a [callback`Gtk`.TextBufferCommitNotify] to be called when a change
             * is to be made to the [type`Gtk`.TextBuffer].
             *
             * Functions are explicitly forbidden from making changes to the
             * [type`Gtk`.TextBuffer] from this callback. It is intended for tracking
             * changes to the buffer only.
             *
             * It may be advantageous to use [callback`Gtk`.TextBufferCommitNotify] over
             * connecting to the [signal`Gtk`.TextBuffer::insert-text] or
             * [signal`Gtk`.TextBuffer::delete-range] signals to avoid ordering issues with
             * other signal handlers which may further modify the [type`Gtk`.TextBuffer].
             * @param flags which notifications should be dispatched to @callback
             * @param commit_notify a   [callback@Gtk.TextBufferCommitNotify] to call for commit notifications
             * @returns a handler id which may be used to remove the commit notify   callback using [method@Gtk.TextBuffer.remove_commit_notify].
             */
            add_commit_notify(flags: TextBufferNotifyFlags | null, commit_notify: TextBufferCommitNotify): number;
            /**
             * Adds the mark at position `where`.
             *
             * The mark must not be added to another buffer, and if its name
             * is not %NULL then there must not be another mark in the buffer
             * with the same name.
             *
             * Emits the [signal`Gtk`.TextBuffer::mark-set] signal as notification
             * of the mark's initial placement.
             * @param mark the mark to add
             * @param where location to place mark
             */
            add_mark(mark: TextMark, where: TextIter): void;
            /**
             * Adds `clipboard` to the list of clipboards in which the selection
             * contents of `buffer` are available.
             *
             * In most cases, `clipboard` will be the `GdkClipboard` returned by
             * [method`Gtk`.Widget.get_primary_clipboard] for a view of `buffer`.
             * @param clipboard a `GdkClipboard`
             */
            add_selection_clipboard(clipboard: Gdk.Clipboard): void;
            /**
             * Emits the “apply-tag” signal on `buffer`.
             *
             * The default handler for the signal applies
             * `tag` to the given range. `start` and `end` do
             * not have to be in order.
             * @param tag a `GtkTextTag`
             * @param start one bound of range to be tagged
             * @param end other bound of range to be tagged
             */
            apply_tag(tag: TextTag, start: TextIter, end: TextIter): void;
            /**
             * Emits the “apply-tag” signal on `buffer`.
             *
             * Calls [method`Gtk`.TextTagTable.lookup] on the buffer’s
             * tag table to get a `GtkTextTag`, then calls
             * [method`Gtk`.TextBuffer.apply_tag].
             * @param name name of a named `GtkTextTag`
             * @param start one bound of range to be tagged
             * @param end other bound of range to be tagged
             */
            apply_tag_by_name(name: string, start: TextIter, end: TextIter): void;
            /**
             * Performs the appropriate action as if the user hit the delete
             * key with the cursor at the position specified by `iter`.
             *
             * In the normal case a single character will be deleted, but when
             * combining accents are involved, more than one character can
             * be deleted, and when precomposed character and accent combinations
             * are involved, less than one character will be deleted.
             *
             * Because the buffer is modified, all outstanding iterators become
             * invalid after calling this function; however, the `iter` will be
             * re-initialized to point to the location where text was deleted.
             * @param iter a position in @buffer
             * @param interactive whether the deletion is caused by user interaction
             * @param default_editable whether the buffer is editable by default
             * @returns %TRUE if the buffer was modified
             */
            backspace(iter: TextIter, interactive: boolean, default_editable: boolean): boolean;
            /**
             * Denotes the beginning of an action that may not be undone.
             *
             * This will cause any previous operations in the undo/redo queue
             * to be cleared.
             *
             * This should be paired with a call to
             * [method`Gtk`.TextBuffer.end_irreversible_action] after the irreversible
             * action has completed.
             *
             * You may nest calls to gtk_text_buffer_begin_irreversible_action()
             * and gtk_text_buffer_end_irreversible_action() pairs.
             */
            begin_irreversible_action(): void;
            /**
             * Called to indicate that the buffer operations between here and a
             * call to gtk_text_buffer_end_user_action() are part of a single
             * user-visible operation.
             *
             * The operations between gtk_text_buffer_begin_user_action() and
             * gtk_text_buffer_end_user_action() can then be grouped when creating
             * an undo stack. `GtkTextBuffer` maintains a count of calls to
             * gtk_text_buffer_begin_user_action() that have not been closed with
             * a call to gtk_text_buffer_end_user_action(), and emits the
             * “begin-user-action” and “end-user-action” signals only for the
             * outermost pair of calls. This allows you to build user actions
             * from other user actions.
             *
             * The “interactive” buffer mutation functions, such as
             * [method`Gtk`.TextBuffer.insert_interactive], automatically call
             * begin/end user action around the buffer operations they perform,
             * so there's no need to add extra calls if you user action consists
             * solely of a single call to one of those functions.
             */
            begin_user_action(): void;
            /**
             * Copies the currently-selected text to a clipboard.
             * @param clipboard the `GdkClipboard` object to copy to
             */
            copy_clipboard(clipboard: Gdk.Clipboard): void;
            /**
             * Creates and inserts a child anchor.
             *
             * This is a convenience function which simply creates a child anchor
             * with [ctor`Gtk`.TextChildAnchor.new] and inserts it into the buffer
             * with [method`Gtk`.TextBuffer.insert_child_anchor].
             *
             * The new anchor is owned by the buffer; no reference count is
             * returned to the caller of this function.
             * @param iter location in the buffer
             * @returns the created child anchor
             */
            create_child_anchor(iter: TextIter): TextChildAnchor;
            /**
             * Creates a mark at position `where`.
             *
             * If `mark_name` is %NULL, the mark is anonymous; otherwise, the mark
             * can be retrieved by name using [method`Gtk`.TextBuffer.get_mark].
             * If a mark has left gravity, and text is inserted at the mark’s
             * current location, the mark will be moved to the left of the
             * newly-inserted text. If the mark has right gravity
             * (`left_gravity` = %FALSE), the mark will end up on the right of
             * newly-inserted text. The standard left-to-right cursor is a mark
             * with right gravity (when you type, the cursor stays on the right
             * side of the text you’re typing).
             *
             * The caller of this function does not own a
             * reference to the returned `GtkTextMark`, so you can ignore the
             * return value if you like. Marks are owned by the buffer and go
             * away when the buffer does.
             *
             * Emits the [signal`Gtk`.TextBuffer::mark-set] signal as notification
             * of the mark's initial placement.
             * @param mark_name name for mark
             * @param where location to place mark
             * @param left_gravity whether the mark has left gravity
             * @returns the new `GtkTextMark` object
             */
            create_mark(mark_name: string | null, where: TextIter, left_gravity: boolean): TextMark;
            /**
             * Copies the currently-selected text to a clipboard,
             * then deletes said text if it’s editable.
             * @param clipboard the `GdkClipboard` object to cut to
             * @param default_editable default editability of the buffer
             */
            cut_clipboard(clipboard: Gdk.Clipboard, default_editable: boolean): void;
            /**
             * Deletes text between `start` and `end`.
             *
             * The order of `start` and `end` is not actually relevant;
             * gtk_text_buffer_delete() will reorder them.
             *
             * This function actually emits the “delete-range” signal, and
             * the default handler of that signal deletes the text. Because the
             * buffer is modified, all outstanding iterators become invalid after
             * calling this function; however, the `start` and `end` will be
             * re-initialized to point to the location where text was deleted.
             * @param start a position in @buffer
             * @param end another position in @buffer
             */
            ['delete'](start: TextIter, end: TextIter): void;
            /**
             * Deletes all editable text in the given range.
             *
             * Calls [method`Gtk`.TextBuffer.delete] for each editable
             * sub-range of [`start,``end)`. `start` and `end` are revalidated
             * to point to the location of the last deleted range, or left
             * untouched if no text was deleted.
             * @param start_iter start of range to delete
             * @param end_iter end of range
             * @param default_editable whether the buffer is editable by default
             * @returns whether some text was actually deleted
             */
            delete_interactive(start_iter: TextIter, end_iter: TextIter, default_editable: boolean): boolean;
            /**
             * Deletes `mark,` so that it’s no longer located anywhere in the
             * buffer.
             *
             * Removes the reference the buffer holds to the mark, so if
             * you haven’t called g_object_ref() on the mark, it will be freed.
             * Even if the mark isn’t freed, most operations on `mark` become
             * invalid, until it gets added to a buffer again with
             * [method`Gtk`.TextBuffer.add_mark]. Use [method`Gtk`.TextMark.get_deleted]
             * to find out if a mark has been removed from its buffer.
             *
             * The [signal`Gtk`.TextBuffer::mark-deleted] signal will be emitted as
             * notification after the mark is deleted.
             * @param mark a `GtkTextMark` in @buffer
             */
            delete_mark(mark: TextMark): void;
            /**
             * Deletes the mark named `name;` the mark must exist.
             *
             * See [method`Gtk`.TextBuffer.delete_mark] for details.
             * @param name name of a mark in @buffer
             */
            delete_mark_by_name(name: string): void;
            /**
             * Deletes the range between the “insert” and “selection_bound” marks,
             * that is, the currently-selected text.
             *
             * If `interactive` is %TRUE, the editability of the selection will be
             * considered (users can’t delete uneditable text).
             * @param interactive whether the deletion is caused by user interaction
             * @param default_editable whether the buffer is editable by default
             * @returns whether there was a non-empty selection to delete
             */
            delete_selection(interactive: boolean, default_editable: boolean): boolean;
            /**
             * Denotes the end of an action that may not be undone.
             *
             * This will cause any previous operations in the undo/redo
             * queue to be cleared.
             *
             * This should be called after completing modifications to the
             * text buffer after [method`Gtk`.TextBuffer.begin_irreversible_action]
             * was called.
             *
             * You may nest calls to gtk_text_buffer_begin_irreversible_action()
             * and gtk_text_buffer_end_irreversible_action() pairs.
             */
            end_irreversible_action(): void;
            /**
             * Ends a user-visible operation.
             *
             * Should be paired with a call to
             * [method`Gtk`.TextBuffer.begin_user_action].
             * See that function for a full explanation.
             */
            end_user_action(): void;
            /**
             * Retrieves the first and last iterators in the buffer, i.e. the
             * entire buffer lies within the range [`start,``end)`.
             */
            get_bounds(): [TextIter, TextIter];
            /**
             * Gets whether there is a redoable action in the history.
             * @returns %TRUE if there is a redoable action
             */
            get_can_redo(): boolean;
            /**
             * Gets whether there is an undoable action in the history.
             * @returns %TRUE if there is an undoable action
             */
            get_can_undo(): boolean;
            /**
             * Gets the number of characters in the buffer.
             *
             * Note that characters and bytes are not the same, you can’t e.g.
             * expect the contents of the buffer in string form to be this
             * many bytes long.
             *
             * The character count is cached, so this function is very fast.
             * @returns number of characters in the buffer
             */
            get_char_count(): number;
            /**
             * Gets whether the buffer is saving modifications to the buffer
             * to allow for undo and redo actions.
             *
             * See [method`Gtk`.TextBuffer.begin_irreversible_action] and
             * [method`Gtk`.TextBuffer.end_irreversible_action] to create
             * changes to the buffer that cannot be undone.
             * @returns %TRUE if undoing and redoing changes to the buffer is allowed.
             */
            get_enable_undo(): boolean;
            /**
             * Initializes `iter` with the “end iterator,” one past the last valid
             * character in the text buffer.
             *
             * If dereferenced with [method`Gtk`.TextIter.get_char], the end
             * iterator has a character value of 0.
             * The entire buffer lies in the range from the first position in
             * the buffer (call [method`Gtk`.TextBuffer.get_start_iter] to get
             * character position 0) to the end iterator.
             */
            get_end_iter(): TextIter;
            /**
             * Indicates whether the buffer has some text currently selected.
             * @returns %TRUE if the there is text selected
             */
            get_has_selection(): boolean;
            /**
             * Returns the mark that represents the cursor (insertion point).
             *
             * Equivalent to calling [method`Gtk`.TextBuffer.get_mark]
             * to get the mark named “insert”, but very slightly more
             * efficient, and involves less typing.
             * @returns insertion point mark
             */
            get_insert(): TextMark;
            /**
             * Obtains the location of `anchor` within `buffer`.
             * @param anchor a child anchor that appears in @buffer
             */
            get_iter_at_child_anchor(anchor: TextChildAnchor): TextIter;
            /**
             * Initializes `iter` to the start of the given line.
             *
             * If `line_number` is greater than or equal to the number of lines
             * in the `buffer,` the end iterator is returned.
             * @param line_number line number counting from 0
             * @returns whether the exact position has been found
             */
            get_iter_at_line(line_number: number): [boolean, TextIter];
            /**
             * Obtains an iterator pointing to `byte_index` within the given line.
             *
             * `byte_index` must be the start of a UTF-8 character. Note bytes, not
             * characters; UTF-8 may encode one character as multiple bytes.
             *
             * If `line_number` is greater than or equal to the number of lines in the `buffer,`
             * the end iterator is returned. And if `byte_index` is off the
             * end of the line, the iterator at the end of the line is returned.
             * @param line_number line number counting from 0
             * @param byte_index byte index from start of line
             * @returns whether the exact position has been found
             */
            get_iter_at_line_index(line_number: number, byte_index: number): [boolean, TextIter];
            /**
             * Obtains an iterator pointing to `char_offset` within the given line.
             *
             * Note characters, not bytes; UTF-8 may encode one character as multiple
             * bytes.
             *
             * If `line_number` is greater than or equal to the number of lines in the `buffer,`
             * the end iterator is returned. And if `char_offset` is off the
             * end of the line, the iterator at the end of the line is returned.
             * @param line_number line number counting from 0
             * @param char_offset char offset from start of line
             * @returns whether the exact position has been found
             */
            get_iter_at_line_offset(line_number: number, char_offset: number): [boolean, TextIter];
            /**
             * Initializes `iter` with the current position of `mark`.
             * @param mark a `GtkTextMark` in @buffer
             */
            get_iter_at_mark(mark: TextMark): TextIter;
            /**
             * Initializes `iter` to a position `char_offset` chars from the start
             * of the entire buffer.
             *
             * If `char_offset` is -1 or greater than the number
             * of characters in the buffer, `iter` is initialized to the end iterator,
             * the iterator one past the last valid character in the buffer.
             * @param char_offset char offset from start of buffer, counting from 0, or -1
             */
            get_iter_at_offset(char_offset: number): TextIter;
            /**
             * Obtains the number of lines in the buffer.
             *
             * This value is cached, so the function is very fast.
             * @returns number of lines in the buffer
             */
            get_line_count(): number;
            /**
             * Returns the mark named `name` in buffer `buffer,` or %NULL if no such
             * mark exists in the buffer.
             * @param name a mark name
             * @returns a `GtkTextMark`
             */
            get_mark(name: string): TextMark | null;
            /**
             * Gets the maximum number of undo levels to perform.
             *
             * If 0, unlimited undo actions may be performed. Note that this may
             * have a memory usage impact as it requires storing an additional
             * copy of the inserted or removed text within the text buffer.
             * @returns The max number of undo levels allowed (0 indicates unlimited).
             */
            get_max_undo_levels(): number;
            /**
             * Indicates whether the buffer has been modified since the last call
             * to [method`Gtk`.TextBuffer.set_modified] set the modification flag to
             * %FALSE.
             *
             * Used for example to enable a “save” function in a text editor.
             * @returns %TRUE if the buffer has been modified
             */
            get_modified(): boolean;
            /**
             * Returns the mark that represents the selection bound.
             *
             * Equivalent to calling [method`Gtk`.TextBuffer.get_mark]
             * to get the mark named “selection_bound”, but very slightly
             * more efficient, and involves less typing.
             *
             * The currently-selected text in `buffer` is the region between the
             * “selection_bound” and “insert” marks. If “selection_bound” and
             * “insert” are in the same place, then there is no current selection.
             * [method`Gtk`.TextBuffer.get_selection_bounds] is another convenient
             * function for handling the selection, if you just want to know whether
             * there’s a selection and what its bounds are.
             * @returns selection bound mark
             */
            get_selection_bound(): TextMark;
            /**
             * Returns %TRUE if some text is selected; places the bounds
             * of the selection in `start` and `end`.
             *
             * If the selection has length 0, then `start` and `end` are filled
             * in with the same value. `start` and `end` will be in ascending order.
             * If `start` and `end` are %NULL, then they are not filled in, but the
             * return value still indicates whether text is selected.
             * @returns whether the selection has nonzero length
             */
            get_selection_bounds(): [boolean, TextIter, TextIter];
            /**
             * Get a content provider for this buffer.
             *
             * It can be used to make the content of `buffer` available
             * in a `GdkClipboard`, see [method`Gdk`.Clipboard.set_content].
             * @returns a new `GdkContentProvider`.
             */
            get_selection_content(): Gdk.ContentProvider;
            /**
             * Returns the text in the range [`start,``end)`.
             *
             * Excludes undisplayed text (text marked with tags that set the
             * invisibility attribute) if `include_hidden_chars` is %FALSE.
             * The returned string includes a 0xFFFC character whenever the
             * buffer contains embedded images, so byte and character indexes
             * into the returned string do correspond to byte and character
             * indexes into the buffer. Contrast with [method`Gtk`.TextBuffer.get_text].
             * Note that 0xFFFC can occur in normal text as well, so it is not a
             * reliable indicator that a paintable or widget is in the buffer.
             * @param start start of a range
             * @param end end of a range
             * @param include_hidden_chars whether to include invisible text
             * @returns an allocated UTF-8 string
             */
            get_slice(start: TextIter, end: TextIter, include_hidden_chars: boolean): string;
            /**
             * Initialized `iter` with the first position in the text buffer.
             *
             * This is the same as using [method`Gtk`.TextBuffer.get_iter_at_offset]
             * to get the iter at character offset 0.
             */
            get_start_iter(): TextIter;
            /**
             * Get the `GtkTextTagTable` associated with this buffer.
             * @returns the buffer’s tag table
             */
            get_tag_table(): TextTagTable;
            /**
             * Returns the text in the range [`start,``end)`.
             *
             * Excludes undisplayed text (text marked with tags that set the
             * invisibility attribute) if `include_hidden_chars` is %FALSE.
             * Does not include characters representing embedded images, so
             * byte and character indexes into the returned string do not
             * correspond to byte and character indexes into the buffer.
             * Contrast with [method`Gtk`.TextBuffer.get_slice].
             * @param start start of a range
             * @param end end of a range
             * @param include_hidden_chars whether to include invisible text
             * @returns an allocated UTF-8 string
             */
            get_text(start: TextIter, end: TextIter, include_hidden_chars: boolean): string;
            /**
             * Inserts `len` bytes of `text` at position `iter`.
             *
             * If `len` is -1, `text` must be nul-terminated and will be inserted in its
             * entirety. Emits the “insert-text” signal; insertion actually occurs
             * in the default handler for the signal. `iter` is invalidated when
             * insertion occurs (because the buffer contents change), but the
             * default signal handler revalidates it to point to the end of the
             * inserted text.
             * @param iter a position in the buffer
             * @param text text in UTF-8 format
             * @param len length of text in bytes, or -1
             */
            insert(iter: TextIter, text: string, len: number): void;
            /**
             * Inserts `text` in `buffer`.
             *
             * Simply calls [method`Gtk`.TextBuffer.insert],
             * using the current cursor position as the insertion point.
             * @param text text in UTF-8 format
             * @param len length of text, in bytes
             */
            insert_at_cursor(text: string, len: number): void;
            /**
             * Inserts a child widget anchor into the text buffer at `iter`.
             *
             * The anchor will be counted as one character in character counts, and
             * when obtaining the buffer contents as a string, will be represented
             * by the Unicode “object replacement character” 0xFFFC. Note that the
             * “slice” variants for obtaining portions of the buffer as a string
             * include this character for child anchors, but the “text” variants do
             * not. E.g. see [method`Gtk`.TextBuffer.get_slice] and
             * [method`Gtk`.TextBuffer.get_text].
             *
             * Consider [method`Gtk`.TextBuffer.create_child_anchor] as a more
             * convenient alternative to this function. The buffer will add a
             * reference to the anchor, so you can unref it after insertion.
             * @param iter location to insert the anchor
             * @param anchor a `GtkTextChildAnchor`
             */
            insert_child_anchor(iter: TextIter, anchor: TextChildAnchor): void;
            /**
             * Inserts `text` in `buffer`.
             *
             * Like [method`Gtk`.TextBuffer.insert], but the insertion will not occur
             * if `iter` is at a non-editable location in the buffer. Usually you
             * want to prevent insertions at ineditable locations if the insertion
             * results from a user action (is interactive).
             *
             * `default_editable` indicates the editability of text that doesn't
             * have a tag affecting editability applied to it. Typically the
             * result of [method`Gtk`.TextView.get_editable] is appropriate here.
             * @param iter a position in @buffer
             * @param text some UTF-8 text
             * @param len length of text in bytes, or -1
             * @param default_editable default editability of buffer
             * @returns whether text was actually inserted
             */
            insert_interactive(iter: TextIter, text: string, len: number, default_editable: boolean): boolean;
            /**
             * Inserts `text` in `buffer`.
             *
             * Calls [method`Gtk`.TextBuffer.insert_interactive]
             * at the cursor position.
             *
             * `default_editable` indicates the editability of text that doesn't
             * have a tag affecting editability applied to it. Typically the
             * result of [method`Gtk`.TextView.get_editable] is appropriate here.
             * @param text text in UTF-8 format
             * @param len length of text in bytes, or -1
             * @param default_editable default editability of buffer
             * @returns whether text was actually inserted
             */
            insert_interactive_at_cursor(text: string, len: number, default_editable: boolean): boolean;
            /**
             * Inserts the text in `markup` at position `iter`.
             *
             * `markup` will be inserted in its entirety and must be nul-terminated
             * and valid UTF-8. Emits the [signal`Gtk`.TextBuffer::insert-text] signal,
             * possibly multiple times; insertion actually occurs in the default handler
             * for the signal. `iter` will point to the end of the inserted text on return.
             * @param iter location to insert the markup
             * @param markup a nul-terminated UTF-8 string containing Pango markup
             * @param len length of @markup in bytes, or -1
             */
            insert_markup(iter: TextIter, markup: string, len: number): void;
            /**
             * Inserts an image into the text buffer at `iter`.
             *
             * The image will be counted as one character in character counts,
             * and when obtaining the buffer contents as a string, will be
             * represented by the Unicode “object replacement character” 0xFFFC.
             * Note that the “slice” variants for obtaining portions of the buffer
             * as a string include this character for paintable, but the “text”
             * variants do not. e.g. see [method`Gtk`.TextBuffer.get_slice] and
             * [method`Gtk`.TextBuffer.get_text].
             * @param iter location to insert the paintable
             * @param paintable a `GdkPaintable`
             */
            insert_paintable(iter: TextIter, paintable: Gdk.Paintable): void;
            /**
             * Copies text, tags, and paintables between `start` and `end`
             * and inserts the copy at `iter`.
             *
             * The order of `start` and `end` doesn’t matter.
             *
             * Used instead of simply getting/inserting text because it preserves
             * images and tags. If `start` and `end` are in a different buffer from
             * `buffer,` the two buffers must share the same tag table.
             *
             * Implemented via emissions of the ::insert-text and ::apply-tag signals,
             * so expect those.
             * @param iter a position in @buffer
             * @param start a position in a `GtkTextBuffer`
             * @param end another position in the same buffer as @start
             */
            insert_range(iter: TextIter, start: TextIter, end: TextIter): void;
            /**
             * Copies text, tags, and paintables between `start` and `end`
             * and inserts the copy at `iter`.
             *
             * Same as [method`Gtk`.TextBuffer.insert_range], but does nothing
             * if the insertion point isn’t editable. The `default_editable`
             * parameter indicates whether the text is editable at `iter` if
             * no tags enclosing `iter` affect editability. Typically the result
             * of [method`Gtk`.TextView.get_editable] is appropriate here.
             * @param iter a position in @buffer
             * @param start a position in a `GtkTextBuffer`
             * @param end another position in the same buffer as @start
             * @param default_editable default editability of the buffer
             * @returns whether an insertion was possible at @iter
             */
            insert_range_interactive(
                iter: TextIter,
                start: TextIter,
                end: TextIter,
                default_editable: boolean,
            ): boolean;
            /**
             * Moves `mark` to the new location `where`.
             *
             * Emits the [signal`Gtk`.TextBuffer::mark-set] signal
             * as notification of the move.
             * @param mark a `GtkTextMark`
             * @param where new location for @mark in @buffer
             */
            move_mark(mark: TextMark, where: TextIter): void;
            /**
             * Moves the mark named `name` (which must exist) to location `where`.
             *
             * See [method`Gtk`.TextBuffer.move_mark] for details.
             * @param name name of a mark
             * @param where new location for mark
             */
            move_mark_by_name(name: string, where: TextIter): void;
            /**
             * Pastes the contents of a clipboard.
             *
             * If `override_location` is %NULL, the pasted text will be inserted
             * at the cursor position, or the buffer selection will be replaced
             * if the selection is non-empty.
             *
             * Note: pasting is asynchronous, that is, we’ll ask for the paste data
             * and return, and at some point later after the main loop runs, the paste
             * data will be inserted.
             * @param clipboard the `GdkClipboard` to paste from
             * @param override_location location to insert pasted text
             * @param default_editable whether the buffer is editable by default
             */
            paste_clipboard(
                clipboard: Gdk.Clipboard,
                override_location: TextIter | null,
                default_editable: boolean,
            ): void;
            /**
             * This function moves the “insert” and “selection_bound” marks
             * simultaneously.
             *
             * If you move them to the same place in two steps with
             * [method`Gtk`.TextBuffer.move_mark], you will temporarily select a
             * region in between their old and new locations, which can be pretty
             * inefficient since the temporarily-selected region will force stuff
             * to be recalculated. This function moves them as a unit, which can
             * be optimized.
             * @param where where to put the cursor
             */
            place_cursor(where: TextIter): void;
            /**
             * Redoes the next redoable action on the buffer, if there is one.
             */
            redo(): void;
            /**
             * Removes all tags in the range between `start` and `end`.
             *
             * Be careful with this function; it could remove tags added in code
             * unrelated to the code you’re currently writing. That is, using this
             * function is probably a bad idea if you have two or more unrelated
             * code sections that add tags.
             * @param start one bound of range to be untagged
             * @param end other bound of range to be untagged
             */
            remove_all_tags(start: TextIter, end: TextIter): void;
            /**
             * Removes the `GtkTextBufferCommitNotify` handler previously registered
             * with [method`Gtk`.TextBuffer.add_commit_notify].
             *
             * This may result in the `user_data_destroy` being called that was passed when registering
             * the commit notify functions.
             * @param commit_notify_handler the notify handler identifier returned from   [method@Gtk.TextBuffer.add_commit_notify].
             */
            remove_commit_notify(commit_notify_handler: number): void;
            /**
             * Removes a `GdkClipboard` added with
             * [method`Gtk`.TextBuffer.add_selection_clipboard]
             * @param clipboard a `GdkClipboard` added to @buffer by   [method@Gtk.TextBuffer.add_selection_clipboard]
             */
            remove_selection_clipboard(clipboard: Gdk.Clipboard): void;
            /**
             * Emits the “remove-tag” signal.
             *
             * The default handler for the signal removes all occurrences
             * of `tag` from the given range. `start` and `end` don’t have
             * to be in order.
             * @param tag a `GtkTextTag`
             * @param start one bound of range to be untagged
             * @param end other bound of range to be untagged
             */
            remove_tag(tag: TextTag, start: TextIter, end: TextIter): void;
            /**
             * Emits the “remove-tag” signal.
             *
             * Calls [method`Gtk`.TextTagTable.lookup] on the buffer’s
             * tag table to get a `GtkTextTag`, then calls
             * [method`Gtk`.TextBuffer.remove_tag].
             * @param name name of a `GtkTextTag`
             * @param start one bound of range to be untagged
             * @param end other bound of range to be untagged
             */
            remove_tag_by_name(name: string, start: TextIter, end: TextIter): void;
            /**
             * This function moves the “insert” and “selection_bound” marks
             * simultaneously.
             *
             * If you move them in two steps with
             * [method`Gtk`.TextBuffer.move_mark], you will temporarily select a
             * region in between their old and new locations, which can be pretty
             * inefficient since the temporarily-selected region will force stuff
             * to be recalculated. This function moves them as a unit, which can
             * be optimized.
             * @param ins where to put the “insert” mark
             * @param bound where to put the “selection_bound” mark
             */
            select_range(ins: TextIter, bound: TextIter): void;
            /**
             * Sets whether or not to enable undoable actions in the text buffer.
             *
             * Undoable actions in this context are changes to the text content of
             * the buffer. Changes to tags and marks are not tracked.
             *
             * If enabled, the user will be able to undo the last number of actions
             * up to [method`Gtk`.TextBuffer.get_max_undo_levels].
             *
             * See [method`Gtk`.TextBuffer.begin_irreversible_action] and
             * [method`Gtk`.TextBuffer.end_irreversible_action] to create
             * changes to the buffer that cannot be undone.
             * @param enable_undo %TRUE to enable undo
             */
            set_enable_undo(enable_undo: boolean): void;
            /**
             * Sets the maximum number of undo levels to perform.
             *
             * If 0, unlimited undo actions may be performed. Note that this may
             * have a memory usage impact as it requires storing an additional
             * copy of the inserted or removed text within the text buffer.
             * @param max_undo_levels the maximum number of undo actions to perform
             */
            set_max_undo_levels(max_undo_levels: number): void;
            /**
             * Used to keep track of whether the buffer has been
             * modified since the last time it was saved.
             *
             * Whenever the buffer is saved to disk, call
             * `gtk_text_buffer_set_modified (`buffer,` FALSE)`.
             * When the buffer is modified, it will automatically
             * toggle on the modified bit again. When the modified
             * bit flips, the buffer emits the
             * [signal`Gtk`.TextBuffer::modified-changed] signal.
             * @param setting modification flag setting
             */
            set_modified(setting: boolean): void;
            /**
             * Deletes current contents of `buffer,` and inserts `text` instead. This is
             * automatically marked as an irreversible action in the undo stack. If you
             * wish to mark this action as part of a larger undo operation, call
             * [method`TextBuffer`.delete] and [method`TextBuffer`.insert] directly instead.
             *
             * If `len` is -1, `text` must be nul-terminated.
             * `text` must be valid UTF-8.
             * @param text UTF-8 text to insert
             * @param len length of @text in bytes
             */
            set_text(text: string, len: number): void;
            /**
             * Undoes the last undoable action on the buffer, if there is one.
             */
            undo(): void;
        }

        namespace TextChildAnchor {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * A `GtkTextChildAnchor` is a spot in a `GtkTextBuffer` where child widgets can
         * be “anchored”.
         *
         * The anchor can have multiple widgets anchored, to allow for multiple views.
         */
        class TextChildAnchor extends GObject.Object {
            static $gtype: GObject.GType<TextChildAnchor>;

            // Constructors

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

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

            static ['new'](): TextChildAnchor;

            static new_with_replacement(character: string): TextChildAnchor;

            // Methods

            /**
             * Determines whether a child anchor has been deleted from
             * the buffer.
             *
             * Keep in mind that the child anchor will be unreferenced
             * when removed from the buffer, so you need to hold your own
             * reference (with g_object_ref()) if you plan to use this
             * function — otherwise all deleted child anchors will also
             * be finalized.
             * @returns %TRUE if the child anchor has been deleted from its buffer
             */
            get_deleted(): boolean;
            /**
             * Gets a list of all widgets anchored at this child anchor.
             *
             * The order in which the widgets are returned is not defined.
             * @returns an   array of widgets anchored at @anchor
             */
            get_widgets(): Widget[];
        }

        namespace TextMark {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                left_gravity: boolean;
                leftGravity: boolean;
                name: string;
            }
        }

        /**
         * A `GtkTextMark` is a position in a `GtkTextbuffer` that is preserved
         * across modifications.
         *
         * You may wish to begin by reading the
         * [text widget conceptual overview](section-text-widget.html),
         * which gives an overview of all the objects and data types
         * related to the text widget and how they work together.
         *
         * A `GtkTextMark` is like a bookmark in a text buffer; it preserves
         * a position in the text. You can convert the mark to an iterator using
         * [method`Gtk`.TextBuffer.get_iter_at_mark]. Unlike iterators, marks remain
         * valid across buffer mutations, because their behavior is defined when
         * text is inserted or deleted. When text containing a mark is deleted,
         * the mark remains in the position originally occupied by the deleted
         * text. When text is inserted at a mark, a mark with “left gravity” will
         * be moved to the beginning of the newly-inserted text, and a mark with
         * “right gravity” will be moved to the end.
         *
         * Note that “left” and “right” here refer to logical direction (left
         * is the toward the start of the buffer); in some languages such as
         * Hebrew the logically-leftmost text is not actually on the left when
         * displayed.
         *
         * Marks are reference counted, but the reference count only controls
         * the validity of the memory; marks can be deleted from the buffer at
         * any time with [method`Gtk`.TextBuffer.delete_mark]. Once deleted from
         * the buffer, a mark is essentially useless.
         *
         * Marks optionally have names; these can be convenient to avoid passing
         * the `GtkTextMark` object around.
         *
         * Marks are typically created using the [method`Gtk`.TextBuffer.create_mark]
         * function.
         */
        class TextMark extends GObject.Object {
            static $gtype: GObject.GType<TextMark>;

            // Properties

            /**
             * Whether the mark has left gravity.
             *
             * When text is inserted at the mark’s current location, if the mark
             * has left gravity it will be moved to the left of the newly-inserted
             * text, otherwise to the right.
             */
            get left_gravity(): boolean;
            /**
             * Whether the mark has left gravity.
             *
             * When text is inserted at the mark’s current location, if the mark
             * has left gravity it will be moved to the left of the newly-inserted
             * text, otherwise to the right.
             */
            get leftGravity(): boolean;
            /**
             * The name of the mark or %NULL if the mark is anonymous.
             */
            get name(): string;

            // Constructors

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

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

            static ['new'](name: string | null, left_gravity: boolean): TextMark;

            // Methods

            /**
             * Gets the buffer this mark is located inside.
             *
             * Returns %NULL if the mark is deleted.
             * @returns the mark’s `GtkTextBuffer`
             */
            get_buffer(): TextBuffer | null;
            /**
             * Returns %TRUE if the mark has been removed from its buffer.
             *
             * See [method`Gtk`.TextBuffer.add_mark] for a way to add it
             * to a buffer again.
             * @returns whether the mark is deleted
             */
            get_deleted(): boolean;
            /**
             * Determines whether the mark has left gravity.
             * @returns %TRUE if the mark has left gravity, %FALSE otherwise
             */
            get_left_gravity(): boolean;
            /**
             * Returns the mark name.
             *
             * Returns %NULL for anonymous marks.
             * @returns mark name
             */
            get_name(): string | null;
            /**
             * Returns %TRUE if the mark is visible.
             *
             * A cursor is displayed for visible marks.
             * @returns %TRUE if visible
             */
            get_visible(): boolean;
            /**
             * Sets the visibility of `mark`.
             *
             * The insertion point is normally visible, i.e. you can see it as
             * a vertical bar. Also, the text widget uses a visible mark to
             * indicate where a drop will occur when dragging-and-dropping text.
             * Most other marks are not visible.
             *
             * Marks are not visible by default.
             * @param setting visibility of mark
             */
            set_visible(setting: boolean): void;
        }

        namespace TextTag {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                accumulative_margin: boolean;
                accumulativeMargin: boolean;
                allow_breaks: boolean;
                allowBreaks: boolean;
                allow_breaks_set: boolean;
                allowBreaksSet: boolean;
                background: string;
                background_full_height: boolean;
                backgroundFullHeight: boolean;
                background_full_height_set: boolean;
                backgroundFullHeightSet: boolean;
                background_rgba: Gdk.RGBA;
                backgroundRgba: Gdk.RGBA;
                background_set: boolean;
                backgroundSet: boolean;
                direction: TextDirection;
                editable: boolean;
                editable_set: boolean;
                editableSet: boolean;
                fallback: boolean;
                fallback_set: boolean;
                fallbackSet: boolean;
                family: string;
                family_set: boolean;
                familySet: boolean;
                font: string;
                font_desc: Pango.FontDescription;
                fontDesc: Pango.FontDescription;
                font_features: string;
                fontFeatures: string;
                font_features_set: boolean;
                fontFeaturesSet: boolean;
                foreground: string;
                foreground_rgba: Gdk.RGBA;
                foregroundRgba: Gdk.RGBA;
                foreground_set: boolean;
                foregroundSet: boolean;
                indent: number;
                indent_set: boolean;
                indentSet: boolean;
                insert_hyphens: boolean;
                insertHyphens: boolean;
                insert_hyphens_set: boolean;
                insertHyphensSet: boolean;
                invisible: boolean;
                invisible_set: boolean;
                invisibleSet: boolean;
                justification: Justification;
                justification_set: boolean;
                justificationSet: boolean;
                language: string;
                language_set: boolean;
                languageSet: boolean;
                left_margin: number;
                leftMargin: number;
                left_margin_set: boolean;
                leftMarginSet: boolean;
                letter_spacing: number;
                letterSpacing: number;
                letter_spacing_set: boolean;
                letterSpacingSet: boolean;
                line_height: number;
                lineHeight: number;
                line_height_set: boolean;
                lineHeightSet: boolean;
                name: string;
                overline: Pango.Overline;
                overline_rgba: Gdk.RGBA;
                overlineRgba: Gdk.RGBA;
                overline_rgba_set: boolean;
                overlineRgbaSet: boolean;
                overline_set: boolean;
                overlineSet: boolean;
                paragraph_background: string;
                paragraphBackground: string;
                paragraph_background_rgba: Gdk.RGBA;
                paragraphBackgroundRgba: Gdk.RGBA;
                paragraph_background_set: boolean;
                paragraphBackgroundSet: boolean;
                pixels_above_lines: number;
                pixelsAboveLines: number;
                pixels_above_lines_set: boolean;
                pixelsAboveLinesSet: boolean;
                pixels_below_lines: number;
                pixelsBelowLines: number;
                pixels_below_lines_set: boolean;
                pixelsBelowLinesSet: boolean;
                pixels_inside_wrap: number;
                pixelsInsideWrap: number;
                pixels_inside_wrap_set: boolean;
                pixelsInsideWrapSet: boolean;
                right_margin: number;
                rightMargin: number;
                right_margin_set: boolean;
                rightMarginSet: boolean;
                rise: number;
                rise_set: boolean;
                riseSet: boolean;
                scale: number;
                scale_set: boolean;
                scaleSet: boolean;
                sentence: boolean;
                sentence_set: boolean;
                sentenceSet: boolean;
                show_spaces: Pango.ShowFlags;
                showSpaces: Pango.ShowFlags;
                show_spaces_set: boolean;
                showSpacesSet: boolean;
                size: number;
                size_points: number;
                sizePoints: number;
                size_set: boolean;
                sizeSet: boolean;
                stretch: Pango.Stretch;
                stretch_set: boolean;
                stretchSet: boolean;
                strikethrough: boolean;
                strikethrough_rgba: Gdk.RGBA;
                strikethroughRgba: Gdk.RGBA;
                strikethrough_rgba_set: boolean;
                strikethroughRgbaSet: boolean;
                strikethrough_set: boolean;
                strikethroughSet: boolean;
                style: Pango.Style;
                style_set: boolean;
                styleSet: boolean;
                tabs: Pango.TabArray;
                tabs_set: boolean;
                tabsSet: boolean;
                text_transform: Pango.TextTransform;
                textTransform: Pango.TextTransform;
                text_transform_set: boolean;
                textTransformSet: boolean;
                underline: Pango.Underline;
                underline_rgba: Gdk.RGBA;
                underlineRgba: Gdk.RGBA;
                underline_rgba_set: boolean;
                underlineRgbaSet: boolean;
                underline_set: boolean;
                underlineSet: boolean;
                variant: Pango.Variant;
                variant_set: boolean;
                variantSet: boolean;
                weight: number;
                weight_set: boolean;
                weightSet: boolean;
                word: boolean;
                word_set: boolean;
                wordSet: boolean;
                wrap_mode: WrapMode;
                wrapMode: WrapMode;
                wrap_mode_set: boolean;
                wrapModeSet: boolean;
            }
        }

        /**
         * A tag that can be applied to text contained in a `GtkTextBuffer`.
         *
         * You may wish to begin by reading the
         * [text widget conceptual overview](section-text-widget.html),
         * which gives an overview of all the objects and data types
         * related to the text widget and how they work together.
         *
         * Tags should be in the [class`Gtk`.TextTagTable] for a given
         * `GtkTextBuffer` before using them with that buffer.
         *
         * [method`Gtk`.TextBuffer.create_tag] is the best way to create tags.
         * See “gtk4-demo” for numerous examples.
         *
         * For each property of `GtkTextTag`, there is a “set” property, e.g.
         * “font-set” corresponds to “font”. These “set” properties reflect
         * whether a property has been set or not.
         *
         * They are maintained by GTK and you should not set them independently.
         */
        class TextTag extends GObject.Object {
            static $gtype: GObject.GType<TextTag>;

            // Properties

            /**
             * Whether the margins accumulate or override each other.
             *
             * When set to %TRUE the margins of this tag are added to the margins
             * of any other non-accumulative margins present. When set to %FALSE
             * the margins override one another (the default).
             */
            get accumulative_margin(): boolean;
            set accumulative_margin(val: boolean);
            /**
             * Whether the margins accumulate or override each other.
             *
             * When set to %TRUE the margins of this tag are added to the margins
             * of any other non-accumulative margins present. When set to %FALSE
             * the margins override one another (the default).
             */
            get accumulativeMargin(): boolean;
            set accumulativeMargin(val: boolean);
            /**
             * Whether breaks are allowed.
             */
            get allow_breaks(): boolean;
            set allow_breaks(val: boolean);
            /**
             * Whether breaks are allowed.
             */
            get allowBreaks(): boolean;
            set allowBreaks(val: boolean);
            /**
             * Whether the `allow-breaks` property is set.
             */
            get allow_breaks_set(): boolean;
            set allow_breaks_set(val: boolean);
            /**
             * Whether the `allow-breaks` property is set.
             */
            get allowBreaksSet(): boolean;
            set allowBreaksSet(val: boolean);
            /**
             * Background color as a string.
             */
            set background(val: string);
            /**
             * Whether the background color fills the entire line height
             * or only the height of the tagged characters.
             */
            get background_full_height(): boolean;
            set background_full_height(val: boolean);
            /**
             * Whether the background color fills the entire line height
             * or only the height of the tagged characters.
             */
            get backgroundFullHeight(): boolean;
            set backgroundFullHeight(val: boolean);
            /**
             * Whether the `background-full-height` property is set.
             */
            get background_full_height_set(): boolean;
            set background_full_height_set(val: boolean);
            /**
             * Whether the `background-full-height` property is set.
             */
            get backgroundFullHeightSet(): boolean;
            set backgroundFullHeightSet(val: boolean);
            /**
             * Background color as a `GdkRGBA`.
             */
            get background_rgba(): Gdk.RGBA;
            set background_rgba(val: Gdk.RGBA);
            /**
             * Background color as a `GdkRGBA`.
             */
            get backgroundRgba(): Gdk.RGBA;
            set backgroundRgba(val: Gdk.RGBA);
            /**
             * Whether the `background` property is set.
             */
            get background_set(): boolean;
            set background_set(val: boolean);
            /**
             * Whether the `background` property is set.
             */
            get backgroundSet(): boolean;
            set backgroundSet(val: boolean);
            /**
             * Text direction, e.g. right-to-left or left-to-right.
             */
            get direction(): TextDirection;
            set direction(val: TextDirection);
            /**
             * Whether the text can be modified by the user.
             */
            get editable(): boolean;
            set editable(val: boolean);
            /**
             * Whether the `editable` property is set.
             */
            get editable_set(): boolean;
            set editable_set(val: boolean);
            /**
             * Whether the `editable` property is set.
             */
            get editableSet(): boolean;
            set editableSet(val: boolean);
            /**
             * Whether font fallback is enabled.
             *
             * When set to %TRUE, other fonts will be substituted
             * where the current font is missing glyphs.
             */
            get fallback(): boolean;
            set fallback(val: boolean);
            /**
             * Whether the `fallback` property is set.
             */
            get fallback_set(): boolean;
            set fallback_set(val: boolean);
            /**
             * Whether the `fallback` property is set.
             */
            get fallbackSet(): boolean;
            set fallbackSet(val: boolean);
            /**
             * Name of the font family, e.g. Sans, Helvetica, Times, Monospace.
             */
            get family(): string;
            set family(val: string);
            /**
             * Whether the `family` property is set.
             */
            get family_set(): boolean;
            set family_set(val: boolean);
            /**
             * Whether the `family` property is set.
             */
            get familySet(): boolean;
            set familySet(val: boolean);
            /**
             * Font description as string, e.g. \"Sans Italic 12\".
             *
             * Note that the initial value of this property depends on
             * the internals of `PangoFontDescription`.
             */
            get font(): string;
            set font(val: string);
            /**
             * Font description as a `PangoFontDescription`.
             */
            get font_desc(): Pango.FontDescription;
            set font_desc(val: Pango.FontDescription);
            /**
             * Font description as a `PangoFontDescription`.
             */
            get fontDesc(): Pango.FontDescription;
            set fontDesc(val: Pango.FontDescription);
            /**
             * OpenType font features, as a string.
             */
            get font_features(): string;
            set font_features(val: string);
            /**
             * OpenType font features, as a string.
             */
            get fontFeatures(): string;
            set fontFeatures(val: string);
            /**
             * Whether the `font-features` property is set.
             */
            get font_features_set(): boolean;
            set font_features_set(val: boolean);
            /**
             * Whether the `font-features` property is set.
             */
            get fontFeaturesSet(): boolean;
            set fontFeaturesSet(val: boolean);
            /**
             * Foreground color as a string.
             */
            set foreground(val: string);
            /**
             * Foreground color as a `GdkRGBA`.
             */
            get foreground_rgba(): Gdk.RGBA;
            set foreground_rgba(val: Gdk.RGBA);
            /**
             * Foreground color as a `GdkRGBA`.
             */
            get foregroundRgba(): Gdk.RGBA;
            set foregroundRgba(val: Gdk.RGBA);
            /**
             * Whether the `foreground` property is set.
             */
            get foreground_set(): boolean;
            set foreground_set(val: boolean);
            /**
             * Whether the `foreground` property is set.
             */
            get foregroundSet(): boolean;
            set foregroundSet(val: boolean);
            /**
             * Amount to indent the paragraph, in pixels.
             *
             * A negative value of indent will produce a hanging indentation.
             * That is, the first line will have the full width, and subsequent
             * lines will be indented by the absolute value of indent.
             */
            get indent(): number;
            set indent(val: number);
            /**
             * Whether the `indent` property is set.
             */
            get indent_set(): boolean;
            set indent_set(val: boolean);
            /**
             * Whether the `indent` property is set.
             */
            get indentSet(): boolean;
            set indentSet(val: boolean);
            /**
             * Whether to insert hyphens at breaks.
             */
            get insert_hyphens(): boolean;
            set insert_hyphens(val: boolean);
            /**
             * Whether to insert hyphens at breaks.
             */
            get insertHyphens(): boolean;
            set insertHyphens(val: boolean);
            /**
             * Whether the `insert-hyphens` property is set.
             */
            get insert_hyphens_set(): boolean;
            set insert_hyphens_set(val: boolean);
            /**
             * Whether the `insert-hyphens` property is set.
             */
            get insertHyphensSet(): boolean;
            set insertHyphensSet(val: boolean);
            /**
             * Whether this text is hidden.
             *
             * Note that there may still be problems with the support for invisible
             * text, in particular when navigating programmatically inside a buffer
             * containing invisible segments.
             */
            get invisible(): boolean;
            set invisible(val: boolean);
            /**
             * Whether the `invisible` property is set.
             */
            get invisible_set(): boolean;
            set invisible_set(val: boolean);
            /**
             * Whether the `invisible` property is set.
             */
            get invisibleSet(): boolean;
            set invisibleSet(val: boolean);
            /**
             * Left, right, or center justification.
             */
            get justification(): Justification;
            set justification(val: Justification);
            /**
             * Whether the `justification` property is set.
             */
            get justification_set(): boolean;
            set justification_set(val: boolean);
            /**
             * Whether the `justification` property is set.
             */
            get justificationSet(): boolean;
            set justificationSet(val: boolean);
            /**
             * The language this text is in, as an ISO code.
             *
             * Pango can use this as a hint when rendering the text.
             * If not set, an appropriate default will be used.
             *
             * Note that the initial value of this property depends
             * on the current locale, see also [func`Gtk`.get_default_language].
             */
            get language(): string;
            set language(val: string);
            /**
             * Whether the `language` property is set.
             */
            get language_set(): boolean;
            set language_set(val: boolean);
            /**
             * Whether the `language` property is set.
             */
            get languageSet(): boolean;
            set languageSet(val: boolean);
            /**
             * Width of the left margin in pixels.
             */
            get left_margin(): number;
            set left_margin(val: number);
            /**
             * Width of the left margin in pixels.
             */
            get leftMargin(): number;
            set leftMargin(val: number);
            /**
             * Whether the `left-margin` property is set.
             */
            get left_margin_set(): boolean;
            set left_margin_set(val: boolean);
            /**
             * Whether the `left-margin` property is set.
             */
            get leftMarginSet(): boolean;
            set leftMarginSet(val: boolean);
            /**
             * Extra spacing between graphemes, in Pango units.
             */
            get letter_spacing(): number;
            set letter_spacing(val: number);
            /**
             * Extra spacing between graphemes, in Pango units.
             */
            get letterSpacing(): number;
            set letterSpacing(val: number);
            /**
             * Whether the `letter-spacing` property is set.
             */
            get letter_spacing_set(): boolean;
            set letter_spacing_set(val: boolean);
            /**
             * Whether the `letter-spacing` property is set.
             */
            get letterSpacingSet(): boolean;
            set letterSpacingSet(val: boolean);
            /**
             * Factor to scale line height by.
             */
            get line_height(): number;
            set line_height(val: number);
            /**
             * Factor to scale line height by.
             */
            get lineHeight(): number;
            set lineHeight(val: number);
            /**
             * Whether the `line-height` property is set.
             */
            get line_height_set(): boolean;
            set line_height_set(val: boolean);
            /**
             * Whether the `line-height` property is set.
             */
            get lineHeightSet(): boolean;
            set lineHeightSet(val: boolean);
            /**
             * The name used to refer to the tag.
             *
             * %NULL for anonymous tags.
             */
            get name(): string;
            /**
             * Style of overline for this text.
             */
            get overline(): Pango.Overline;
            set overline(val: Pango.Overline);
            /**
             * This property modifies the color of overlines.
             *
             * If not set, overlines will use the foreground color.
             */
            get overline_rgba(): Gdk.RGBA;
            set overline_rgba(val: Gdk.RGBA);
            /**
             * This property modifies the color of overlines.
             *
             * If not set, overlines will use the foreground color.
             */
            get overlineRgba(): Gdk.RGBA;
            set overlineRgba(val: Gdk.RGBA);
            /**
             * Whether the `overline-rgba` property is set.
             */
            get overline_rgba_set(): boolean;
            set overline_rgba_set(val: boolean);
            /**
             * Whether the `overline-rgba` property is set.
             */
            get overlineRgbaSet(): boolean;
            set overlineRgbaSet(val: boolean);
            /**
             * Whether the `overline` property is set.
             */
            get overline_set(): boolean;
            set overline_set(val: boolean);
            /**
             * Whether the `overline` property is set.
             */
            get overlineSet(): boolean;
            set overlineSet(val: boolean);
            /**
             * The paragraph background color as a string.
             */
            set paragraph_background(val: string);
            /**
             * The paragraph background color as a string.
             */
            set paragraphBackground(val: string);
            /**
             * The paragraph background color as a `GdkRGBA`.
             */
            get paragraph_background_rgba(): Gdk.RGBA;
            set paragraph_background_rgba(val: Gdk.RGBA);
            /**
             * The paragraph background color as a `GdkRGBA`.
             */
            get paragraphBackgroundRgba(): Gdk.RGBA;
            set paragraphBackgroundRgba(val: Gdk.RGBA);
            /**
             * Whether the `paragraph-background` property is set.
             */
            get paragraph_background_set(): boolean;
            set paragraph_background_set(val: boolean);
            /**
             * Whether the `paragraph-background` property is set.
             */
            get paragraphBackgroundSet(): boolean;
            set paragraphBackgroundSet(val: boolean);
            /**
             * Pixels of blank space above paragraphs.
             */
            get pixels_above_lines(): number;
            set pixels_above_lines(val: number);
            /**
             * Pixels of blank space above paragraphs.
             */
            get pixelsAboveLines(): number;
            set pixelsAboveLines(val: number);
            /**
             * Whether the `pixels-above-lines` property is set.
             */
            get pixels_above_lines_set(): boolean;
            set pixels_above_lines_set(val: boolean);
            /**
             * Whether the `pixels-above-lines` property is set.
             */
            get pixelsAboveLinesSet(): boolean;
            set pixelsAboveLinesSet(val: boolean);
            /**
             * Pixels of blank space below paragraphs.
             */
            get pixels_below_lines(): number;
            set pixels_below_lines(val: number);
            /**
             * Pixels of blank space below paragraphs.
             */
            get pixelsBelowLines(): number;
            set pixelsBelowLines(val: number);
            /**
             * Whether the `pixels-below-lines` property is set.
             */
            get pixels_below_lines_set(): boolean;
            set pixels_below_lines_set(val: boolean);
            /**
             * Whether the `pixels-below-lines` property is set.
             */
            get pixelsBelowLinesSet(): boolean;
            set pixelsBelowLinesSet(val: boolean);
            /**
             * Pixels of blank space between wrapped lines in a paragraph.
             */
            get pixels_inside_wrap(): number;
            set pixels_inside_wrap(val: number);
            /**
             * Pixels of blank space between wrapped lines in a paragraph.
             */
            get pixelsInsideWrap(): number;
            set pixelsInsideWrap(val: number);
            /**
             * Whether the `pixels-inside-wrap` property is set.
             */
            get pixels_inside_wrap_set(): boolean;
            set pixels_inside_wrap_set(val: boolean);
            /**
             * Whether the `pixels-inside-wrap` property is set.
             */
            get pixelsInsideWrapSet(): boolean;
            set pixelsInsideWrapSet(val: boolean);
            /**
             * Width of the right margin, in pixels.
             */
            get right_margin(): number;
            set right_margin(val: number);
            /**
             * Width of the right margin, in pixels.
             */
            get rightMargin(): number;
            set rightMargin(val: number);
            /**
             * Whether the `right-margin` property is set.
             */
            get right_margin_set(): boolean;
            set right_margin_set(val: boolean);
            /**
             * Whether the `right-margin` property is set.
             */
            get rightMarginSet(): boolean;
            set rightMarginSet(val: boolean);
            /**
             * Offset of text above the baseline, in Pango units.
             *
             * Negative values go below the baseline.
             */
            get rise(): number;
            set rise(val: number);
            /**
             * Whether the `rise` property is set.
             */
            get rise_set(): boolean;
            set rise_set(val: boolean);
            /**
             * Whether the `rise` property is set.
             */
            get riseSet(): boolean;
            set riseSet(val: boolean);
            /**
             * Font size as a scale factor relative to the default font size.
             *
             * This properly adapts to theme changes, etc. so is recommended.
             * Pango predefines some scales such as %PANGO_SCALE_X_LARGE.
             */
            get scale(): number;
            set scale(val: number);
            /**
             * Whether the `scale` property is set.
             */
            get scale_set(): boolean;
            set scale_set(val: boolean);
            /**
             * Whether the `scale` property is set.
             */
            get scaleSet(): boolean;
            set scaleSet(val: boolean);
            /**
             * Whether this tag represents a single sentence.
             *
             * This affects cursor movement.
             */
            get sentence(): boolean;
            set sentence(val: boolean);
            /**
             * Whether the `sentence` property is set.
             */
            get sentence_set(): boolean;
            set sentence_set(val: boolean);
            /**
             * Whether the `sentence` property is set.
             */
            get sentenceSet(): boolean;
            set sentenceSet(val: boolean);
            /**
             * How to render invisible characters.
             */
            get show_spaces(): Pango.ShowFlags;
            set show_spaces(val: Pango.ShowFlags);
            /**
             * How to render invisible characters.
             */
            get showSpaces(): Pango.ShowFlags;
            set showSpaces(val: Pango.ShowFlags);
            /**
             * Whether the `show-spaces` property is set.
             */
            get show_spaces_set(): boolean;
            set show_spaces_set(val: boolean);
            /**
             * Whether the `show-spaces` property is set.
             */
            get showSpacesSet(): boolean;
            set showSpacesSet(val: boolean);
            /**
             * Font size in Pango units.
             */
            get size(): number;
            set size(val: number);
            /**
             * Font size in points.
             */
            get size_points(): number;
            set size_points(val: number);
            /**
             * Font size in points.
             */
            get sizePoints(): number;
            set sizePoints(val: number);
            /**
             * Whether the `size` property is set.
             */
            get size_set(): boolean;
            set size_set(val: boolean);
            /**
             * Whether the `size` property is set.
             */
            get sizeSet(): boolean;
            set sizeSet(val: boolean);
            /**
             * Font stretch as a `PangoStretch`, e.g. %PANGO_STRETCH_CONDENSED.
             */
            get stretch(): Pango.Stretch;
            set stretch(val: Pango.Stretch);
            /**
             * Whether the `stretch` property is set.
             */
            get stretch_set(): boolean;
            set stretch_set(val: boolean);
            /**
             * Whether the `stretch` property is set.
             */
            get stretchSet(): boolean;
            set stretchSet(val: boolean);
            /**
             * Whether to strike through the text.
             */
            get strikethrough(): boolean;
            set strikethrough(val: boolean);
            /**
             * This property modifies the color of strikeouts.
             *
             * If not set, strikeouts will use the foreground color.
             */
            get strikethrough_rgba(): Gdk.RGBA;
            set strikethrough_rgba(val: Gdk.RGBA);
            /**
             * This property modifies the color of strikeouts.
             *
             * If not set, strikeouts will use the foreground color.
             */
            get strikethroughRgba(): Gdk.RGBA;
            set strikethroughRgba(val: Gdk.RGBA);
            /**
             * If the `strikethrough-rgba` property has been set.
             */
            get strikethrough_rgba_set(): boolean;
            set strikethrough_rgba_set(val: boolean);
            /**
             * If the `strikethrough-rgba` property has been set.
             */
            get strikethroughRgbaSet(): boolean;
            set strikethroughRgbaSet(val: boolean);
            /**
             * Whether the `strikethrough` property is set.
             */
            get strikethrough_set(): boolean;
            set strikethrough_set(val: boolean);
            /**
             * Whether the `strikethrough` property is set.
             */
            get strikethroughSet(): boolean;
            set strikethroughSet(val: boolean);
            /**
             * Font style as a `PangoStyle`, e.g. %PANGO_STYLE_ITALIC.
             */
            get style(): Pango.Style;
            set style(val: Pango.Style);
            /**
             * Whether the `style` property is set.
             */
            get style_set(): boolean;
            set style_set(val: boolean);
            /**
             * Whether the `style` property is set.
             */
            get styleSet(): boolean;
            set styleSet(val: boolean);
            /**
             * Custom tabs for this text.
             */
            get tabs(): Pango.TabArray;
            set tabs(val: Pango.TabArray);
            /**
             * Whether the `tabs` property is set.
             */
            get tabs_set(): boolean;
            set tabs_set(val: boolean);
            /**
             * Whether the `tabs` property is set.
             */
            get tabsSet(): boolean;
            set tabsSet(val: boolean);
            /**
             * How to transform the text for display.
             */
            get text_transform(): Pango.TextTransform;
            set text_transform(val: Pango.TextTransform);
            /**
             * How to transform the text for display.
             */
            get textTransform(): Pango.TextTransform;
            set textTransform(val: Pango.TextTransform);
            /**
             * Whether the `text-transform` property is set.
             */
            get text_transform_set(): boolean;
            set text_transform_set(val: boolean);
            /**
             * Whether the `text-transform` property is set.
             */
            get textTransformSet(): boolean;
            set textTransformSet(val: boolean);
            /**
             * Style of underline for this text.
             */
            get underline(): Pango.Underline;
            set underline(val: Pango.Underline);
            /**
             * This property modifies the color of underlines.
             *
             * If not set, underlines will use the foreground color.
             *
             * If [property`Gtk`.TextTag:underline] is set to %PANGO_UNDERLINE_ERROR,
             * an alternate color may be applied instead of the foreground. Setting
             * this property will always override those defaults.
             */
            get underline_rgba(): Gdk.RGBA;
            set underline_rgba(val: Gdk.RGBA);
            /**
             * This property modifies the color of underlines.
             *
             * If not set, underlines will use the foreground color.
             *
             * If [property`Gtk`.TextTag:underline] is set to %PANGO_UNDERLINE_ERROR,
             * an alternate color may be applied instead of the foreground. Setting
             * this property will always override those defaults.
             */
            get underlineRgba(): Gdk.RGBA;
            set underlineRgba(val: Gdk.RGBA);
            /**
             * If the `underline-rgba` property has been set.
             */
            get underline_rgba_set(): boolean;
            set underline_rgba_set(val: boolean);
            /**
             * If the `underline-rgba` property has been set.
             */
            get underlineRgbaSet(): boolean;
            set underlineRgbaSet(val: boolean);
            /**
             * Whether the `underline` property is set.
             */
            get underline_set(): boolean;
            set underline_set(val: boolean);
            /**
             * Whether the `underline` property is set.
             */
            get underlineSet(): boolean;
            set underlineSet(val: boolean);
            /**
             * Font variant as a `PangoVariant`, e.g. %PANGO_VARIANT_SMALL_CAPS.
             */
            get variant(): Pango.Variant;
            set variant(val: Pango.Variant);
            /**
             * Whether the `variant` property is set.
             */
            get variant_set(): boolean;
            set variant_set(val: boolean);
            /**
             * Whether the `variant` property is set.
             */
            get variantSet(): boolean;
            set variantSet(val: boolean);
            /**
             * Font weight as an integer.
             */
            get weight(): number;
            set weight(val: number);
            /**
             * Whether the `weight` property is set.
             */
            get weight_set(): boolean;
            set weight_set(val: boolean);
            /**
             * Whether the `weight` property is set.
             */
            get weightSet(): boolean;
            set weightSet(val: boolean);
            /**
             * Whether this tag represents a single word.
             *
             * This affects line breaks and cursor movement.
             */
            get word(): boolean;
            set word(val: boolean);
            /**
             * Whether the `word` property is set.
             */
            get word_set(): boolean;
            set word_set(val: boolean);
            /**
             * Whether the `word` property is set.
             */
            get wordSet(): boolean;
            set wordSet(val: boolean);
            /**
             * Whether to wrap lines never, at word boundaries, or
             * at character boundaries.
             */
            get wrap_mode(): WrapMode;
            set wrap_mode(val: WrapMode);
            /**
             * Whether to wrap lines never, at word boundaries, or
             * at character boundaries.
             */
            get wrapMode(): WrapMode;
            set wrapMode(val: WrapMode);
            /**
             * Whether the `wrap-mode` property is set.
             */
            get wrap_mode_set(): boolean;
            set wrap_mode_set(val: boolean);
            /**
             * Whether the `wrap-mode` property is set.
             */
            get wrapModeSet(): boolean;
            set wrapModeSet(val: boolean);

            // Constructors

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

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

            static ['new'](name?: string | null): TextTag;

            // Methods

            /**
             * Emits the [signal`Gtk`.TextTagTable::tag-changed] signal on the
             * `GtkTextTagTable` where the tag is included.
             *
             * The signal is already emitted when setting a `GtkTextTag` property.
             * This function is useful for a `GtkTextTag` subclass.
             * @param size_changed whether the change affects the `GtkTextView` layout
             */
            changed(size_changed: boolean): void;
            /**
             * Get the tag priority.
             * @returns The tag’s priority.
             */
            get_priority(): number;
            /**
             * Sets the priority of a `GtkTextTag`.
             *
             * Valid priorities start at 0 and go to one less than
             * [method`Gtk`.TextTagTable.get_size]. Each tag in a table
             * has a unique priority; setting the priority of one tag shifts
             * the priorities of all the other tags in the table to maintain
             * a unique priority for each tag.
             *
             * Higher priority tags “win” if two tags both set the same text
             * attribute. When adding a tag to a tag table, it will be assigned
             * the highest priority in the table by default; so normally the
             * precedence of a set of tags is the order in which they were added
             * to the table, or created with [method`Gtk`.TextBuffer.create_tag],
             * which adds the tag to the buffer’s table automatically.
             * @param priority the new priority
             */
            set_priority(priority: number): void;
        }

        namespace TextTagTable {
            // Signal callback interfaces

            interface TagAdded {
                (tag: TextTag): void;
            }

            interface TagChanged {
                (tag: TextTag, size_changed: boolean): void;
            }

            interface TagRemoved {
                (tag: TextTag): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps, Buildable.ConstructorProps {}
        }

        /**
         * The collection of tags in a `GtkTextBuffer`
         *
         * You may wish to begin by reading the
         * [text widget conceptual overview](section-text-widget.html),
         * which gives an overview of all the objects and data types
         * related to the text widget and how they work together.
         *
         * # GtkTextTagTables as GtkBuildable
         *
         * The `GtkTextTagTable` implementation of the `GtkBuildable` interface
         * supports adding tags by specifying “tag” as the “type” attribute
         * of a `<child>` element.
         *
         * An example of a UI definition fragment specifying tags:
         * ```xml
         * <object class="GtkTextTagTable">
         *  <child type="tag">
         *    <object class="GtkTextTag"/>
         *  </child>
         * </object>
         * ```
         */
        class TextTagTable extends GObject.Object implements Buildable {
            static $gtype: GObject.GType<TextTagTable>;

            // Constructors

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

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

            static ['new'](): TextTagTable;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'tag-added', callback: (_source: this, tag: TextTag) => void): number;
            connect_after(signal: 'tag-added', callback: (_source: this, tag: TextTag) => void): number;
            emit(signal: 'tag-added', tag: TextTag): void;
            connect(
                signal: 'tag-changed',
                callback: (_source: this, tag: TextTag, size_changed: boolean) => void,
            ): number;
            connect_after(
                signal: 'tag-changed',
                callback: (_source: this, tag: TextTag, size_changed: boolean) => void,
            ): number;
            emit(signal: 'tag-changed', tag: TextTag, size_changed: boolean): void;
            connect(signal: 'tag-removed', callback: (_source: this, tag: TextTag) => void): number;
            connect_after(signal: 'tag-removed', callback: (_source: this, tag: TextTag) => void): number;
            emit(signal: 'tag-removed', tag: TextTag): void;

            // Methods

            /**
             * Add a tag to the table.
             *
             * The tag is assigned the highest priority in the table.
             *
             * `tag` must not be in a tag table already, and may not have
             * the same name as an already-added tag.
             * @param tag a `GtkTextTag`
             * @returns %TRUE on success.
             */
            add(tag: TextTag): boolean;
            /**
             * Calls `func` on each tag in `table,` with user data `data`.
             *
             * Note that the table may not be modified while iterating
             * over it (you can’t add/remove tags).
             * @param func a function to call on each tag
             */
            foreach(func: TextTagTableForeach): void;
            /**
             * Returns the size of the table (number of tags)
             * @returns number of tags in @table
             */
            get_size(): number;
            /**
             * Look up a named tag.
             * @param name name of a tag
             * @returns The tag
             */
            lookup(name: string): TextTag | null;
            /**
             * Remove a tag from the table.
             *
             * If a `GtkTextBuffer` has `table` as its tag table, the tag is
             * removed from the buffer. The table’s reference to the tag is
             * removed, so the tag will end up destroyed if you don’t have
             * a reference to it.
             * @param tag a `GtkTextTag`
             */
            remove(tag: TextTag): void;

            // Inherited methods
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace TextView {
            // Signal callback interfaces

            interface Backspace {
                (): void;
            }

            interface CopyClipboard {
                (): void;
            }

            interface CutClipboard {
                (): void;
            }

            interface DeleteFromCursor {
                (type: DeleteType, count: number): void;
            }

            interface ExtendSelection {
                (granularity: TextExtendSelection, location: TextIter, start: TextIter, end: TextIter): boolean;
            }

            interface InsertAtCursor {
                (string: string): void;
            }

            interface InsertEmoji {
                (): void;
            }

            interface MoveCursor {
                (step: MovementStep, count: number, extend_selection: boolean): void;
            }

            interface MoveViewport {
                (step: ScrollStep, count: number): void;
            }

            interface PasteClipboard {
                (): void;
            }

            interface PreeditChanged {
                (preedit: string): void;
            }

            interface SelectAll {
                (select: boolean): void;
            }

            interface SetAnchor {
                (): void;
            }

            interface ToggleCursorVisible {
                (): void;
            }

            interface ToggleOverwrite {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    AccessibleText.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Scrollable.ConstructorProps {
                accepts_tab: boolean;
                acceptsTab: boolean;
                bottom_margin: number;
                bottomMargin: number;
                buffer: TextBuffer;
                cursor_visible: boolean;
                cursorVisible: boolean;
                editable: boolean;
                extra_menu: Gio.MenuModel;
                extraMenu: Gio.MenuModel;
                im_module: string;
                imModule: string;
                indent: number;
                input_hints: InputHints;
                inputHints: InputHints;
                input_purpose: InputPurpose;
                inputPurpose: InputPurpose;
                justification: Justification;
                left_margin: number;
                leftMargin: number;
                monospace: boolean;
                overwrite: boolean;
                pixels_above_lines: number;
                pixelsAboveLines: number;
                pixels_below_lines: number;
                pixelsBelowLines: number;
                pixels_inside_wrap: number;
                pixelsInsideWrap: number;
                right_margin: number;
                rightMargin: number;
                tabs: Pango.TabArray;
                top_margin: number;
                topMargin: number;
                wrap_mode: WrapMode;
                wrapMode: WrapMode;
            }
        }

        /**
         * A widget that displays the contents of a [class`Gtk`.TextBuffer].
         *
         * ![An example GtkTextView](multiline-text.png)
         *
         * You may wish to begin by reading the [conceptual overview](section-text-widget.html),
         * which gives an overview of all the objects and data types related to the
         * text widget and how they work together.
         *
         * ## Shortcuts and Gestures
         *
         * `GtkTextView` supports the following keyboard shortcuts:
         *
         * - <kbd>Shift</kbd>+<kbd>F10</kbd> or <kbd>Menu</kbd> opens the context menu.
         * - <kbd>Ctrl</kbd>+<kbd>Z</kbd> undoes the last modification.
         * - <kbd>Ctrl</kbd>+<kbd>Y</kbd> or <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Z</kbd>
         *   redoes the last undone modification.
         *
         * Additionally, the following signals have default keybindings:
         *
         * - [signal`Gtk`.TextView::backspace]
         * - [signal`Gtk`.TextView::copy-clipboard]
         * - [signal`Gtk`.TextView::cut-clipboard]
         * - [signal`Gtk`.TextView::delete-from-cursor]
         * - [signal`Gtk`.TextView::insert-emoji]
         * - [signal`Gtk`.TextView::move-cursor]
         * - [signal`Gtk`.TextView::paste-clipboard]
         * - [signal`Gtk`.TextView::select-all]
         * - [signal`Gtk`.TextView::toggle-cursor-visible]
         * - [signal`Gtk`.TextView::toggle-overwrite]
         *
         * ## Actions
         *
         * `GtkTextView` defines a set of built-in actions:
         *
         * - `clipboard.copy` copies the contents to the clipboard.
         * - `clipboard.cut` copies the contents to the clipboard and deletes it from
         *   the widget.
         * - `clipboard.paste` inserts the contents of the clipboard into the widget.
         * - `menu.popup` opens the context menu.
         * - `misc.insert-emoji` opens the Emoji chooser.
         * - `selection.delete` deletes the current selection.
         * - `selection.select-all` selects all of the widgets content.
         * - `text.redo` redoes the last change to the contents.
         * - `text.undo` undoes the last change to the contents.
         *
         * ## CSS nodes
         *
         * ```
         * textview.view
         * ├── border.top
         * ├── border.left
         * ├── text
         * │   ╰── [selection]
         * ├── border.right
         * ├── border.bottom
         * ╰── [window.popup]
         * ```
         *
         * `GtkTextView` has a main css node with name textview and style class .view,
         * and subnodes for each of the border windows, and the main text area,
         * with names border and text, respectively. The border nodes each get
         * one of the style classes .left, .right, .top or .bottom.
         *
         * A node representing the selection will appear below the text node.
         *
         * If a context menu is opened, the window node will appear as a subnode
         * of the main node.
         *
         * ## Accessibility
         *
         * `GtkTextView` uses the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role.
         */
        class TextView extends Widget implements Accessible, AccessibleText, Buildable, ConstraintTarget, Scrollable {
            static $gtype: GObject.GType<TextView>;

            // Properties

            /**
             * Whether Tab will result in a tab character being entered.
             */
            get accepts_tab(): boolean;
            set accepts_tab(val: boolean);
            /**
             * Whether Tab will result in a tab character being entered.
             */
            get acceptsTab(): boolean;
            set acceptsTab(val: boolean);
            /**
             * The bottom margin for text in the text view.
             *
             * Note that this property is confusingly named. In CSS terms,
             * the value set here is padding, and it is applied in addition
             * to the padding from the theme.
             *
             * Don't confuse this property with [property`Gtk`.Widget:margin-bottom].
             */
            get bottom_margin(): number;
            set bottom_margin(val: number);
            /**
             * The bottom margin for text in the text view.
             *
             * Note that this property is confusingly named. In CSS terms,
             * the value set here is padding, and it is applied in addition
             * to the padding from the theme.
             *
             * Don't confuse this property with [property`Gtk`.Widget:margin-bottom].
             */
            get bottomMargin(): number;
            set bottomMargin(val: number);
            /**
             * The buffer which is displayed.
             */
            get buffer(): TextBuffer;
            set buffer(val: TextBuffer);
            /**
             * If the insertion cursor is shown.
             */
            get cursor_visible(): boolean;
            set cursor_visible(val: boolean);
            /**
             * If the insertion cursor is shown.
             */
            get cursorVisible(): boolean;
            set cursorVisible(val: boolean);
            /**
             * Whether the text can be modified by the user.
             */
            get editable(): boolean;
            set editable(val: boolean);
            /**
             * A menu model whose contents will be appended to the context menu.
             */
            get extra_menu(): Gio.MenuModel;
            set extra_menu(val: Gio.MenuModel);
            /**
             * A menu model whose contents will be appended to the context menu.
             */
            get extraMenu(): Gio.MenuModel;
            set extraMenu(val: Gio.MenuModel);
            /**
             * Which IM (input method) module should be used for this text_view.
             *
             * See [class`Gtk`.IMMulticontext].
             *
             * Setting this to a non-%NULL value overrides the system-wide IM module
             * setting. See the GtkSettings [property`Gtk`.Settings:gtk-im-module] property.
             */
            get im_module(): string;
            set im_module(val: string);
            /**
             * Which IM (input method) module should be used for this text_view.
             *
             * See [class`Gtk`.IMMulticontext].
             *
             * Setting this to a non-%NULL value overrides the system-wide IM module
             * setting. See the GtkSettings [property`Gtk`.Settings:gtk-im-module] property.
             */
            get imModule(): string;
            set imModule(val: string);
            /**
             * Amount to indent the paragraph, in pixels.
             *
             * A negative value of indent will produce a hanging indentation.
             * That is, the first line will have the full width, and subsequent
             * lines will be indented by the absolute value of indent.
             */
            get indent(): number;
            set indent(val: number);
            /**
             * Additional hints (beyond [property`Gtk`.TextView:input-purpose])
             * that allow input methods to fine-tune their behaviour.
             */
            get input_hints(): InputHints;
            set input_hints(val: InputHints);
            /**
             * Additional hints (beyond [property`Gtk`.TextView:input-purpose])
             * that allow input methods to fine-tune their behaviour.
             */
            get inputHints(): InputHints;
            set inputHints(val: InputHints);
            /**
             * The purpose of this text field.
             *
             * This property can be used by on-screen keyboards and other input
             * methods to adjust their behaviour.
             */
            get input_purpose(): InputPurpose;
            set input_purpose(val: InputPurpose);
            /**
             * The purpose of this text field.
             *
             * This property can be used by on-screen keyboards and other input
             * methods to adjust their behaviour.
             */
            get inputPurpose(): InputPurpose;
            set inputPurpose(val: InputPurpose);
            /**
             * Left, right, or center justification.
             */
            get justification(): Justification;
            set justification(val: Justification);
            /**
             * The default left margin for text in the text view.
             *
             * Tags in the buffer may override the default.
             *
             * Note that this property is confusingly named. In CSS terms,
             * the value set here is padding, and it is applied in addition
             * to the padding from the theme.
             */
            get left_margin(): number;
            set left_margin(val: number);
            /**
             * The default left margin for text in the text view.
             *
             * Tags in the buffer may override the default.
             *
             * Note that this property is confusingly named. In CSS terms,
             * the value set here is padding, and it is applied in addition
             * to the padding from the theme.
             */
            get leftMargin(): number;
            set leftMargin(val: number);
            /**
             * Whether text should be displayed in a monospace font.
             *
             * If %TRUE, set the .monospace style class on the
             * text view to indicate that a monospace font is desired.
             */
            get monospace(): boolean;
            set monospace(val: boolean);
            /**
             * Whether entered text overwrites existing contents.
             */
            get overwrite(): boolean;
            set overwrite(val: boolean);
            /**
             * Pixels of blank space above paragraphs.
             */
            get pixels_above_lines(): number;
            set pixels_above_lines(val: number);
            /**
             * Pixels of blank space above paragraphs.
             */
            get pixelsAboveLines(): number;
            set pixelsAboveLines(val: number);
            /**
             * Pixels of blank space below paragraphs.
             */
            get pixels_below_lines(): number;
            set pixels_below_lines(val: number);
            /**
             * Pixels of blank space below paragraphs.
             */
            get pixelsBelowLines(): number;
            set pixelsBelowLines(val: number);
            /**
             * Pixels of blank space between wrapped lines in a paragraph.
             */
            get pixels_inside_wrap(): number;
            set pixels_inside_wrap(val: number);
            /**
             * Pixels of blank space between wrapped lines in a paragraph.
             */
            get pixelsInsideWrap(): number;
            set pixelsInsideWrap(val: number);
            /**
             * The default right margin for text in the text view.
             *
             * Tags in the buffer may override the default.
             *
             * Note that this property is confusingly named. In CSS terms,
             * the value set here is padding, and it is applied in addition
             * to the padding from the theme.
             */
            get right_margin(): number;
            set right_margin(val: number);
            /**
             * The default right margin for text in the text view.
             *
             * Tags in the buffer may override the default.
             *
             * Note that this property is confusingly named. In CSS terms,
             * the value set here is padding, and it is applied in addition
             * to the padding from the theme.
             */
            get rightMargin(): number;
            set rightMargin(val: number);
            /**
             * Custom tabs for this text.
             */
            get tabs(): Pango.TabArray;
            set tabs(val: Pango.TabArray);
            /**
             * The top margin for text in the text view.
             *
             * Note that this property is confusingly named. In CSS terms,
             * the value set here is padding, and it is applied in addition
             * to the padding from the theme.
             *
             * Don't confuse this property with [property`Gtk`.Widget:margin-top].
             */
            get top_margin(): number;
            set top_margin(val: number);
            /**
             * The top margin for text in the text view.
             *
             * Note that this property is confusingly named. In CSS terms,
             * the value set here is padding, and it is applied in addition
             * to the padding from the theme.
             *
             * Don't confuse this property with [property`Gtk`.Widget:margin-top].
             */
            get topMargin(): number;
            set topMargin(val: number);
            /**
             * Whether to wrap lines never, at word boundaries, or at character boundaries.
             */
            get wrap_mode(): WrapMode;
            set wrap_mode(val: WrapMode);
            /**
             * Whether to wrap lines never, at word boundaries, or at character boundaries.
             */
            get wrapMode(): WrapMode;
            set wrapMode(val: WrapMode);

            // Constructors

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

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

            static ['new'](): TextView;

            static new_with_buffer(buffer: TextBuffer): TextView;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'backspace', callback: (_source: this) => void): number;
            connect_after(signal: 'backspace', callback: (_source: this) => void): number;
            emit(signal: 'backspace'): void;
            connect(signal: 'copy-clipboard', callback: (_source: this) => void): number;
            connect_after(signal: 'copy-clipboard', callback: (_source: this) => void): number;
            emit(signal: 'copy-clipboard'): void;
            connect(signal: 'cut-clipboard', callback: (_source: this) => void): number;
            connect_after(signal: 'cut-clipboard', callback: (_source: this) => void): number;
            emit(signal: 'cut-clipboard'): void;
            connect(
                signal: 'delete-from-cursor',
                callback: (_source: this, type: DeleteType, count: number) => void,
            ): number;
            connect_after(
                signal: 'delete-from-cursor',
                callback: (_source: this, type: DeleteType, count: number) => void,
            ): number;
            emit(signal: 'delete-from-cursor', type: DeleteType, count: number): void;
            connect(
                signal: 'extend-selection',
                callback: (
                    _source: this,
                    granularity: TextExtendSelection,
                    location: TextIter,
                    start: TextIter,
                    end: TextIter,
                ) => boolean,
            ): number;
            connect_after(
                signal: 'extend-selection',
                callback: (
                    _source: this,
                    granularity: TextExtendSelection,
                    location: TextIter,
                    start: TextIter,
                    end: TextIter,
                ) => boolean,
            ): number;
            emit(
                signal: 'extend-selection',
                granularity: TextExtendSelection,
                location: TextIter,
                start: TextIter,
                end: TextIter,
            ): void;
            connect(signal: 'insert-at-cursor', callback: (_source: this, string: string) => void): number;
            connect_after(signal: 'insert-at-cursor', callback: (_source: this, string: string) => void): number;
            emit(signal: 'insert-at-cursor', string: string): void;
            connect(signal: 'insert-emoji', callback: (_source: this) => void): number;
            connect_after(signal: 'insert-emoji', callback: (_source: this) => void): number;
            emit(signal: 'insert-emoji'): void;
            connect(
                signal: 'move-cursor',
                callback: (_source: this, step: MovementStep, count: number, extend_selection: boolean) => void,
            ): number;
            connect_after(
                signal: 'move-cursor',
                callback: (_source: this, step: MovementStep, count: number, extend_selection: boolean) => void,
            ): number;
            emit(signal: 'move-cursor', step: MovementStep, count: number, extend_selection: boolean): void;
            connect(
                signal: 'move-viewport',
                callback: (_source: this, step: ScrollStep, count: number) => void,
            ): number;
            connect_after(
                signal: 'move-viewport',
                callback: (_source: this, step: ScrollStep, count: number) => void,
            ): number;
            emit(signal: 'move-viewport', step: ScrollStep, count: number): void;
            connect(signal: 'paste-clipboard', callback: (_source: this) => void): number;
            connect_after(signal: 'paste-clipboard', callback: (_source: this) => void): number;
            emit(signal: 'paste-clipboard'): void;
            connect(signal: 'preedit-changed', callback: (_source: this, preedit: string) => void): number;
            connect_after(signal: 'preedit-changed', callback: (_source: this, preedit: string) => void): number;
            emit(signal: 'preedit-changed', preedit: string): void;
            connect(signal: 'select-all', callback: (_source: this, select: boolean) => void): number;
            connect_after(signal: 'select-all', callback: (_source: this, select: boolean) => void): number;
            emit(signal: 'select-all', select: boolean): void;
            connect(signal: 'set-anchor', callback: (_source: this) => void): number;
            connect_after(signal: 'set-anchor', callback: (_source: this) => void): number;
            emit(signal: 'set-anchor'): void;
            connect(signal: 'toggle-cursor-visible', callback: (_source: this) => void): number;
            connect_after(signal: 'toggle-cursor-visible', callback: (_source: this) => void): number;
            emit(signal: 'toggle-cursor-visible'): void;
            connect(signal: 'toggle-overwrite', callback: (_source: this) => void): number;
            connect_after(signal: 'toggle-overwrite', callback: (_source: this) => void): number;
            emit(signal: 'toggle-overwrite'): void;

            // Virtual methods

            /**
             * The class handler for the `GtkTextView::backspace`
             *   keybinding signal.
             */
            vfunc_backspace(): void;
            /**
             * The class handler for the `GtkTextView::copy-clipboard`
             *   keybinding signal.
             */
            vfunc_copy_clipboard(): void;
            /**
             * The class handler for the `GtkTextView::cut-clipboard`
             *   keybinding signal
             */
            vfunc_cut_clipboard(): void;
            /**
             * The class handler for the `GtkTextView::delete-from-cursor`
             *   keybinding signal.
             * @param type
             * @param count
             */
            vfunc_delete_from_cursor(type: DeleteType, count: number): void;
            /**
             * The class handler for the `GtkTextView::extend-selection` signal.
             * @param granularity
             * @param location
             * @param start
             * @param end
             */
            vfunc_extend_selection(
                granularity: TextExtendSelection,
                location: TextIter,
                start: TextIter,
                end: TextIter,
            ): boolean;
            /**
             * The class handler for the `GtkTextView::insert-at-cursor`
             *   keybinding signal.
             * @param str
             */
            vfunc_insert_at_cursor(str: string): void;
            /**
             * The class handler for the `GtkTextView::insert-emoji` signal.
             */
            vfunc_insert_emoji(): void;
            /**
             * The class handler for the `GtkTextView::move-cursor`
             *   keybinding signal.
             * @param step
             * @param count
             * @param extend_selection
             */
            vfunc_move_cursor(step: MovementStep, count: number, extend_selection: boolean): void;
            /**
             * The class handler for the `GtkTextView::paste-clipboard`
             *   keybinding signal.
             */
            vfunc_paste_clipboard(): void;
            /**
             * The class handler for the `GtkTextView::set-anchor`
             *   keybinding signal.
             */
            vfunc_set_anchor(): void;
            /**
             * The snapshot_layer vfunc is called before and after the text
             *   view is drawing its own text. Applications can override this vfunc
             *   in a subclass to draw customized content underneath or above the
             *   text. In the %GTK_TEXT_VIEW_LAYER_BELOW_TEXT and %GTK_TEXT_VIEW_LAYER_ABOVE_TEXT
             *   layers the drawing is done in the buffer coordinate space.
             * @param layer
             * @param snapshot
             */
            vfunc_snapshot_layer(layer: TextViewLayer, snapshot: Snapshot): void;
            /**
             * The class handler for the `GtkTextView::toggle-overwrite`
             *   keybinding signal.
             */
            vfunc_toggle_overwrite(): void;

            // Methods

            /**
             * Adds a child widget in the text buffer, at the given `anchor`.
             * @param child a `GtkWidget`
             * @param anchor a `GtkTextChildAnchor` in the `GtkTextBuffer` for @text_view
             */
            add_child_at_anchor(child: Widget, anchor: TextChildAnchor): void;
            /**
             * Adds `child` at a fixed coordinate in the `GtkTextView`'s text window.
             *
             * The `xpos` and `ypos` must be in buffer coordinates (see
             * [method`Gtk`.TextView.get_iter_location] to convert to
             * buffer coordinates).
             *
             * `child` will scroll with the text view.
             *
             * If instead you want a widget that will not move with the
             * `GtkTextView` contents see `GtkOverlay`.
             * @param child a `GtkWidget`
             * @param xpos X position of child in window coordinates
             * @param ypos Y position of child in window coordinates
             */
            add_overlay(child: Widget, xpos: number, ypos: number): void;
            /**
             * Moves the given `iter` backward by one display (wrapped) line.
             *
             * A display line is different from a paragraph. Paragraphs are
             * separated by newlines or other paragraph separator characters.
             * Display lines are created by line-wrapping a paragraph. If
             * wrapping is turned off, display lines and paragraphs will be the
             * same. Display lines are divided differently for each view, since
             * they depend on the view’s width; paragraphs are the same in all
             * views, since they depend on the contents of the `GtkTextBuffer`.
             * @param iter a `GtkTextIter`
             * @returns %TRUE if @iter was moved and is not on the end iterator
             */
            backward_display_line(iter: TextIter): boolean;
            /**
             * Moves the given `iter` backward to the next display line start.
             *
             * A display line is different from a paragraph. Paragraphs are
             * separated by newlines or other paragraph separator characters.
             * Display lines are created by line-wrapping a paragraph. If
             * wrapping is turned off, display lines and paragraphs will be the
             * same. Display lines are divided differently for each view, since
             * they depend on the view’s width; paragraphs are the same in all
             * views, since they depend on the contents of the `GtkTextBuffer`.
             * @param iter a `GtkTextIter`
             * @returns %TRUE if @iter was moved and is not on the end iterator
             */
            backward_display_line_start(iter: TextIter): boolean;
            /**
             * Converts buffer coordinates to window coordinates.
             * @param win a `GtkTextWindowType`
             * @param buffer_x buffer x coordinate
             * @param buffer_y buffer y coordinate
             */
            buffer_to_window_coords(win: TextWindowType | null, buffer_x: number, buffer_y: number): [number, number];
            /**
             * Moves the given `iter` forward by one display (wrapped) line.
             *
             * A display line is different from a paragraph. Paragraphs are
             * separated by newlines or other paragraph separator characters.
             * Display lines are created by line-wrapping a paragraph. If
             * wrapping is turned off, display lines and paragraphs will be the
             * same. Display lines are divided differently for each view, since
             * they depend on the view’s width; paragraphs are the same in all
             * views, since they depend on the contents of the `GtkTextBuffer`.
             * @param iter a `GtkTextIter`
             * @returns %TRUE if @iter was moved and is not on the end iterator
             */
            forward_display_line(iter: TextIter): boolean;
            /**
             * Moves the given `iter` forward to the next display line end.
             *
             * A display line is different from a paragraph. Paragraphs are
             * separated by newlines or other paragraph separator characters.
             * Display lines are created by line-wrapping a paragraph. If
             * wrapping is turned off, display lines and paragraphs will be the
             * same. Display lines are divided differently for each view, since
             * they depend on the view’s width; paragraphs are the same in all
             * views, since they depend on the contents of the `GtkTextBuffer`.
             * @param iter a `GtkTextIter`
             * @returns %TRUE if @iter was moved and is not on the end iterator
             */
            forward_display_line_end(iter: TextIter): boolean;
            /**
             * Returns whether pressing the <kbd>Tab</kbd> key inserts a tab characters.
             *
             * See [method`Gtk`.TextView.set_accepts_tab].
             * @returns %TRUE if pressing the Tab key inserts a tab character,   %FALSE if pressing the Tab key moves the keyboard focus.
             */
            get_accepts_tab(): boolean;
            /**
             * Gets the bottom margin for text in the `text_view`.
             * @returns bottom margin in pixels
             */
            get_bottom_margin(): number;
            /**
             * Returns the `GtkTextBuffer` being displayed by this text view.
             *
             * The reference count on the buffer is not incremented; the caller
             * of this function won’t own a new reference.
             * @returns a `GtkTextBuffer`
             */
            get_buffer(): TextBuffer;
            /**
             * Determine the positions of the strong and weak cursors if the
             * insertion point is at `iter`.
             *
             * The position of each cursor is stored as a zero-width rectangle.
             * The strong cursor location is the location where characters of
             * the directionality equal to the base direction of the paragraph
             * are inserted. The weak cursor location is the location where
             * characters of the directionality opposite to the base direction
             * of the paragraph are inserted.
             *
             * If `iter` is %NULL, the actual cursor position is used.
             *
             * Note that if `iter` happens to be the actual cursor position, and
             * there is currently an IM preedit sequence being entered, the
             * returned locations will be adjusted to account for the preedit
             * cursor’s offset within the preedit sequence.
             *
             * The rectangle position is in buffer coordinates; use
             * [method`Gtk`.TextView.buffer_to_window_coords] to convert these
             * coordinates to coordinates for one of the windows in the text view.
             * @param iter a `GtkTextIter`
             */
            get_cursor_locations(iter?: TextIter | null): [Gdk.Rectangle | null, Gdk.Rectangle | null];
            /**
             * Find out whether the cursor should be displayed.
             * @returns whether the insertion mark is visible
             */
            get_cursor_visible(): boolean;
            /**
             * Returns the default editability of the `GtkTextView`.
             *
             * Tags in the buffer may override this setting for some ranges of text.
             * @returns whether text is editable by default
             */
            get_editable(): boolean;
            /**
             * Gets the menu model that gets added to the context menu
             * or %NULL if none has been set.
             * @returns the menu model
             */
            get_extra_menu(): Gio.MenuModel;
            /**
             * Gets a `GtkWidget` that has previously been set as gutter.
             *
             * See [method`Gtk`.TextView.set_gutter].
             *
             * `win` must be one of %GTK_TEXT_WINDOW_LEFT, %GTK_TEXT_WINDOW_RIGHT,
             * %GTK_TEXT_WINDOW_TOP, or %GTK_TEXT_WINDOW_BOTTOM.
             * @param win a `GtkTextWindowType`
             * @returns a `GtkWidget`
             */
            get_gutter(win: TextWindowType | null): Widget | null;
            /**
             * Gets the default indentation of paragraphs in `text_view`.
             *
             * Tags in the view’s buffer may override the default.
             * The indentation may be negative.
             * @returns number of pixels of indentation
             */
            get_indent(): number;
            /**
             * Gets the `input-hints` of the `GtkTextView`.
             * @returns the input hints
             */
            get_input_hints(): InputHints;
            /**
             * Gets the `input-purpose` of the `GtkTextView`.
             * @returns the input purpose
             */
            get_input_purpose(): InputPurpose;
            /**
             * Retrieves the iterator at buffer coordinates `x` and `y`.
             *
             * Buffer coordinates are coordinates for the entire buffer, not just
             * the currently-displayed portion. If you have coordinates from an
             * event, you have to convert those to buffer coordinates with
             * [method`Gtk`.TextView.window_to_buffer_coords].
             * @param x x position, in buffer coordinates
             * @param y y position, in buffer coordinates
             * @returns %TRUE if the position is over text
             */
            get_iter_at_location(x: number, y: number): [boolean, TextIter];
            /**
             * Retrieves the iterator pointing to the character at buffer
             * coordinates `x` and `y`.
             *
             * Buffer coordinates are coordinates for the entire buffer, not just
             * the currently-displayed portion. If you have coordinates from an event,
             * you have to convert those to buffer coordinates with
             * [method`Gtk`.TextView.window_to_buffer_coords].
             *
             * Note that this is different from [method`Gtk`.TextView.get_iter_at_location],
             * which returns cursor locations, i.e. positions between characters.
             * @param x x position, in buffer coordinates
             * @param y y position, in buffer coordinates
             * @returns %TRUE if the position is over text
             */
            get_iter_at_position(x: number, y: number): [boolean, TextIter, number];
            /**
             * Gets a rectangle which roughly contains the character at `iter`.
             *
             * The rectangle position is in buffer coordinates; use
             * [method`Gtk`.TextView.buffer_to_window_coords] to convert these
             * coordinates to coordinates for one of the windows in the text view.
             * @param iter a `GtkTextIter`
             */
            get_iter_location(iter: TextIter): Gdk.Rectangle;
            /**
             * Gets the default justification of paragraphs in `text_view`.
             *
             * Tags in the buffer may override the default.
             * @returns default justification
             */
            get_justification(): Justification;
            /**
             * Gets the default left margin size of paragraphs in the `text_view`.
             *
             * Tags in the buffer may override the default.
             * @returns left margin in pixels
             */
            get_left_margin(): number;
            /**
             * Gets the `GtkTextIter` at the start of the line containing
             * the coordinate `y`.
             *
             * `y` is in buffer coordinates, convert from window coordinates with
             * [method`Gtk`.TextView.window_to_buffer_coords]. If non-%NULL,
             * `line_top` will be filled with the coordinate of the top edge
             * of the line.
             * @param y a y coordinate
             */
            get_line_at_y(y: number): [TextIter, number];
            /**
             * Gets the y coordinate of the top of the line containing `iter,`
             * and the height of the line.
             *
             * The coordinate is a buffer coordinate; convert to window
             * coordinates with [method`Gtk`.TextView.buffer_to_window_coords].
             * @param iter a `GtkTextIter`
             */
            get_line_yrange(iter: TextIter): [number, number];
            /**
             * Gets the `PangoContext` that is used for rendering LTR directed
             * text layouts.
             *
             * The context may be replaced when CSS changes occur.
             * @returns a `PangoContext`
             */
            get_ltr_context(): Pango.Context;
            /**
             * Gets whether the `GtkTextView` uses monospace styling.
             * @returns %TRUE if monospace fonts are desired
             */
            get_monospace(): boolean;
            /**
             * Returns whether the `GtkTextView` is in overwrite mode or not.
             * @returns whether @text_view is in overwrite mode or not.
             */
            get_overwrite(): boolean;
            /**
             * Gets the default number of pixels to put above paragraphs.
             *
             * Adding this function with [method`Gtk`.TextView.get_pixels_below_lines]
             * is equal to the line space between each paragraph.
             * @returns default number of pixels above paragraphs
             */
            get_pixels_above_lines(): number;
            /**
             * Gets the default number of pixels to put below paragraphs.
             *
             * The line space is the sum of the value returned by this function and
             * the value returned by [method`Gtk`.TextView.get_pixels_above_lines].
             * @returns default number of blank pixels below paragraphs
             */
            get_pixels_below_lines(): number;
            /**
             * Gets the default number of pixels to put between wrapped lines
             * inside a paragraph.
             * @returns default number of pixels of blank space between wrapped lines
             */
            get_pixels_inside_wrap(): number;
            /**
             * Gets the default right margin for text in `text_view`.
             *
             * Tags in the buffer may override the default.
             * @returns right margin in pixels
             */
            get_right_margin(): number;
            /**
             * Gets the `PangoContext` that is used for rendering RTL directed
             * text layouts.
             *
             * The context may be replaced when CSS changes occur.
             * @returns a `PangoContext`
             */
            get_rtl_context(): Pango.Context;
            /**
             * Gets the default tabs for `text_view`.
             *
             * Tags in the buffer may override the defaults. The returned array
             * will be %NULL if “standard” (8-space) tabs are used. Free the
             * return value with [method`Pango`.TabArray.free].
             * @returns copy of default tab array,   or %NULL if standard tabs are used; must be freed with   [method@Pango.TabArray.free].
             */
            get_tabs(): Pango.TabArray | null;
            /**
             * Gets the top margin for text in the `text_view`.
             * @returns top margin in pixels
             */
            get_top_margin(): number;
            /**
             * Fills `visible_rect` with the currently-visible
             * region of the buffer, in buffer coordinates.
             *
             * Convert to window coordinates with
             * [method`Gtk`.TextView.buffer_to_window_coords].
             */
            get_visible_rect(): Gdk.Rectangle;
            /**
             * Gets the line wrapping for the view.
             * @returns the line wrap setting
             */
            get_wrap_mode(): WrapMode;
            /**
             * Allow the `GtkTextView` input method to internally handle key press
             * and release events.
             *
             * If this function returns %TRUE, then no further processing should be
             * done for this key event. See [method`Gtk`.IMContext.filter_keypress].
             *
             * Note that you are expected to call this function from your handler
             * when overriding key event handling. This is needed in the case when
             * you need to insert your own key handling between the input method
             * and the default key event handling of the `GtkTextView`.
             *
             * ```c
             * static gboolean
             * gtk_foo_bar_key_press_event (GtkWidget *widget,
             *                              GdkEvent  *event)
             * {
             *   guint keyval;
             *
             *   gdk_event_get_keyval ((GdkEvent*)event, &keyval);
             *
             *   if (keyval == GDK_KEY_Return || keyval == GDK_KEY_KP_Enter)
             *     {
             *       if (gtk_text_view_im_context_filter_keypress (GTK_TEXT_VIEW (widget), event))
             *         return TRUE;
             *     }
             *
             *   // Do some stuff
             *
             *   return GTK_WIDGET_CLASS (gtk_foo_bar_parent_class)->key_press_event (widget, event);
             * }
             * ```
             * @param event the key event
             * @returns %TRUE if the input method handled the key event.
             */
            im_context_filter_keypress(event: Gdk.Event): boolean;
            /**
             * Moves a mark within the buffer so that it's
             * located within the currently-visible text area.
             * @param mark a `GtkTextMark`
             * @returns %TRUE if the mark moved (wasn’t already onscreen)
             */
            move_mark_onscreen(mark: TextMark): boolean;
            /**
             * Updates the position of a child.
             *
             * See [method`Gtk`.TextView.add_overlay].
             * @param child a widget already added with [method@Gtk.TextView.add_overlay]
             * @param xpos new X position in buffer coordinates
             * @param ypos new Y position in buffer coordinates
             */
            move_overlay(child: Widget, xpos: number, ypos: number): void;
            /**
             * Move the iterator a given number of characters visually, treating
             * it as the strong cursor position.
             *
             * If `count` is positive, then the new strong cursor position will
             * be `count` positions to the right of the old cursor position.
             * If `count` is negative then the new strong cursor position will
             * be `count` positions to the left of the old cursor position.
             *
             * In the presence of bi-directional text, the correspondence
             * between logical and visual order will depend on the direction
             * of the current run, and there may be jumps when the cursor
             * is moved off of the end of a run.
             * @param iter a `GtkTextIter`
             * @param count number of characters to move (negative moves left,    positive moves right)
             * @returns %TRUE if @iter moved and is not on the end iterator
             */
            move_visually(iter: TextIter, count: number): boolean;
            /**
             * Moves the cursor to the currently visible region of the
             * buffer.
             * @returns %TRUE if the cursor had to be moved.
             */
            place_cursor_onscreen(): boolean;
            /**
             * Removes a child widget from `text_view`.
             * @param child the child to remove
             */
            remove(child: Widget): void;
            /**
             * Ensures that the cursor is shown.
             *
             * This also resets the time that it will stay blinking (or
             * visible, in case blinking is disabled).
             *
             * This function should be called in response to user input
             * (e.g. from derived classes that override the textview's
             * event handlers).
             */
            reset_cursor_blink(): void;
            /**
             * Reset the input method context of the text view if needed.
             *
             * This can be necessary in the case where modifying the buffer
             * would confuse on-going input method behavior.
             */
            reset_im_context(): void;
            /**
             * Scrolls `text_view` the minimum distance such that `mark` is contained
             * within the visible area of the widget.
             * @param mark a mark in the buffer for @text_view
             */
            scroll_mark_onscreen(mark: TextMark): void;
            /**
             * Scrolls `text_view` so that `iter` is on the screen in the position
             * indicated by `xalign` and `yalign`.
             *
             * An alignment of 0.0 indicates left or top, 1.0 indicates right or
             * bottom, 0.5 means center. If `use_align` is %FALSE, the text scrolls
             * the minimal distance to get the mark onscreen, possibly not scrolling
             * at all. The effective screen for purposes of this function is reduced
             * by a margin of size `within_margin`.
             *
             * Note that this function uses the currently-computed height of the
             * lines in the text buffer. Line heights are computed in an idle
             * handler; so this function may not have the desired effect if it’s
             * called before the height computations. To avoid oddness, consider
             * using [method`Gtk`.TextView.scroll_to_mark] which saves a point to be
             * scrolled to after line validation.
             * @param iter a `GtkTextIter`
             * @param within_margin margin as a [0.0,0.5) fraction of screen size
             * @param use_align whether to use alignment arguments (if %FALSE,    just get the mark onscreen)
             * @param xalign horizontal alignment of mark within visible area
             * @param yalign vertical alignment of mark within visible area
             * @returns %TRUE if scrolling occurred
             */
            scroll_to_iter(
                iter: TextIter,
                within_margin: number,
                use_align: boolean,
                xalign: number,
                yalign: number,
            ): boolean;
            /**
             * Scrolls `text_view` so that `mark` is on the screen in the position
             * indicated by `xalign` and `yalign`.
             *
             * An alignment of 0.0 indicates left or top, 1.0 indicates right or
             * bottom, 0.5 means center. If `use_align` is %FALSE, the text scrolls
             * the minimal distance to get the mark onscreen, possibly not scrolling
             * at all. The effective screen for purposes of this function is reduced
             * by a margin of size `within_margin`.
             * @param mark a `GtkTextMark`
             * @param within_margin margin as a [0.0,0.5) fraction of screen size
             * @param use_align whether to use alignment arguments (if %FALSE, just    get the mark onscreen)
             * @param xalign horizontal alignment of mark within visible area
             * @param yalign vertical alignment of mark within visible area
             */
            scroll_to_mark(
                mark: TextMark,
                within_margin: number,
                use_align: boolean,
                xalign: number,
                yalign: number,
            ): void;
            /**
             * Sets the behavior of the text widget when the <kbd>Tab</kbd> key is pressed.
             *
             * If `accepts_tab` is %TRUE, a tab character is inserted. If `accepts_tab`
             * is %FALSE the keyboard focus is moved to the next widget in the focus
             * chain.
             *
             * Focus can always be moved using <kbd>Ctrl</kbd>+<kbd>Tab</kbd>.
             * @param accepts_tab %TRUE if pressing the Tab key should insert a tab    character, %FALSE, if pressing the Tab key should move the    keyboard focus.
             */
            set_accepts_tab(accepts_tab: boolean): void;
            /**
             * Sets the bottom margin for text in `text_view`.
             *
             * Note that this function is confusingly named.
             * In CSS terms, the value set here is padding.
             * @param bottom_margin bottom margin in pixels
             */
            set_bottom_margin(bottom_margin: number): void;
            /**
             * Sets `buffer` as the buffer being displayed by `text_view`.
             *
             * The previous buffer displayed by the text view is unreferenced, and
             * a reference is added to `buffer`. If you owned a reference to `buffer`
             * before passing it to this function, you must remove that reference
             * yourself; `GtkTextView` will not “adopt” it.
             * @param buffer a `GtkTextBuffer`
             */
            set_buffer(buffer?: TextBuffer | null): void;
            /**
             * Toggles whether the insertion point should be displayed.
             *
             * A buffer with no editable text probably shouldn’t have a visible
             * cursor, so you may want to turn the cursor off.
             *
             * Note that this property may be overridden by the
             * [property`Gtk`.Settings:gtk-keynav-use-caret] setting.
             * @param setting whether to show the insertion cursor
             */
            set_cursor_visible(setting: boolean): void;
            /**
             * Sets the default editability of the `GtkTextView`.
             *
             * You can override this default setting with tags in the buffer,
             * using the “editable” attribute of tags.
             * @param setting whether it’s editable
             */
            set_editable(setting: boolean): void;
            /**
             * Sets a menu model to add when constructing the context
             * menu for `text_view`.
             *
             * You can pass %NULL to remove a previously set extra menu.
             * @param model a `GMenuModel`
             */
            set_extra_menu(model?: Gio.MenuModel | null): void;
            /**
             * Places `widget` into the gutter specified by `win`.
             *
             * `win` must be one of %GTK_TEXT_WINDOW_LEFT, %GTK_TEXT_WINDOW_RIGHT,
             * %GTK_TEXT_WINDOW_TOP, or %GTK_TEXT_WINDOW_BOTTOM.
             * @param win a `GtkTextWindowType`
             * @param widget a `GtkWidget`
             */
            set_gutter(win: TextWindowType | null, widget?: Widget | null): void;
            /**
             * Sets the default indentation for paragraphs in `text_view`.
             *
             * Tags in the buffer may override the default.
             * @param indent indentation in pixels
             */
            set_indent(indent: number): void;
            /**
             * Sets the `input-hints` of the `GtkTextView`.
             *
             * The `input-hints` allow input methods to fine-tune
             * their behaviour.
             * @param hints the hints
             */
            set_input_hints(hints: InputHints | null): void;
            /**
             * Sets the `input-purpose` of the `GtkTextView`.
             *
             * The `input-purpose` can be used by on-screen keyboards
             * and other input methods to adjust their behaviour.
             * @param purpose the purpose
             */
            set_input_purpose(purpose: InputPurpose | null): void;
            /**
             * Sets the default justification of text in `text_view`.
             *
             * Tags in the view’s buffer may override the default.
             * @param justification justification
             */
            set_justification(justification: Justification | null): void;
            /**
             * Sets the default left margin for text in `text_view`.
             *
             * Tags in the buffer may override the default.
             *
             * Note that this function is confusingly named.
             * In CSS terms, the value set here is padding.
             * @param left_margin left margin in pixels
             */
            set_left_margin(left_margin: number): void;
            /**
             * Sets whether the `GtkTextView` should display text in
             * monospace styling.
             * @param monospace %TRUE to request monospace styling
             */
            set_monospace(monospace: boolean): void;
            /**
             * Changes the `GtkTextView` overwrite mode.
             * @param overwrite %TRUE to turn on overwrite mode, %FALSE to turn it off
             */
            set_overwrite(overwrite: boolean): void;
            /**
             * Sets the default number of blank pixels above paragraphs in `text_view`.
             *
             * Tags in the buffer for `text_view` may override the defaults.
             * @param pixels_above_lines pixels above paragraphs
             */
            set_pixels_above_lines(pixels_above_lines: number): void;
            /**
             * Sets the default number of pixels of blank space
             * to put below paragraphs in `text_view`.
             *
             * May be overridden by tags applied to `text_view’`s buffer.
             * @param pixels_below_lines pixels below paragraphs
             */
            set_pixels_below_lines(pixels_below_lines: number): void;
            /**
             * Sets the default number of pixels of blank space to leave between
             * display/wrapped lines within a paragraph.
             *
             * May be overridden by tags in `text_view’`s buffer.
             * @param pixels_inside_wrap default number of pixels between wrapped lines
             */
            set_pixels_inside_wrap(pixels_inside_wrap: number): void;
            /**
             * Sets the default right margin for text in the text view.
             *
             * Tags in the buffer may override the default.
             *
             * Note that this function is confusingly named.
             * In CSS terms, the value set here is padding.
             * @param right_margin right margin in pixels
             */
            set_right_margin(right_margin: number): void;
            /**
             * Sets the default tab stops for paragraphs in `text_view`.
             *
             * Tags in the buffer may override the default.
             * @param tabs tabs as a `PangoTabArray`
             */
            set_tabs(tabs: Pango.TabArray): void;
            /**
             * Sets the top margin for text in `text_view`.
             *
             * Note that this function is confusingly named.
             * In CSS terms, the value set here is padding.
             * @param top_margin top margin in pixels
             */
            set_top_margin(top_margin: number): void;
            /**
             * Sets the line wrapping for the view.
             * @param wrap_mode a `GtkWrapMode`
             */
            set_wrap_mode(wrap_mode: WrapMode | null): void;
            /**
             * Determines whether `iter` is at the start of a display line.
             *
             * See [method`Gtk`.TextView.forward_display_line] for an
             * explanation of display lines vs. paragraphs.
             * @param iter a `GtkTextIter`
             * @returns %TRUE if @iter begins a wrapped line
             */
            starts_display_line(iter: TextIter): boolean;
            /**
             * Converts coordinates on the window identified by `win` to buffer
             * coordinates.
             * @param win a `GtkTextWindowType`
             * @param window_x window x coordinate
             * @param window_y window y coordinate
             */
            window_to_buffer_coords(win: TextWindowType | null, window_x: number, window_y: number): [number, number];

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * Horizontal `GtkAdjustment` of the scrollable widget.
             *
             * This adjustment is shared between the scrollable widget and its parent.
             */
            get hadjustment(): Adjustment;
            set hadjustment(val: Adjustment);
            /**
             * Determines when horizontal scrolling should start.
             */
            get hscroll_policy(): ScrollablePolicy;
            set hscroll_policy(val: ScrollablePolicy);
            /**
             * Determines when horizontal scrolling should start.
             */
            get hscrollPolicy(): ScrollablePolicy;
            set hscrollPolicy(val: ScrollablePolicy);
            /**
             * Vertical `GtkAdjustment` of the scrollable widget.
             *
             * This adjustment is shared between the scrollable widget and its parent.
             */
            get vadjustment(): Adjustment;
            set vadjustment(val: Adjustment);
            /**
             * Determines when vertical scrolling should start.
             */
            get vscroll_policy(): ScrollablePolicy;
            set vscroll_policy(val: ScrollablePolicy);
            /**
             * Determines when vertical scrolling should start.
             */
            get vscrollPolicy(): ScrollablePolicy;
            set vscrollPolicy(val: ScrollablePolicy);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Updates the position of the caret.
             *
             * Implementations of the `GtkAccessibleText` interface should call this
             * function every time the caret has moved, in order to notify assistive
             * technologies.
             */
            update_caret_position(): void;
            /**
             * Notifies assistive technologies of a change in contents.
             *
             * Implementations of the `GtkAccessibleText` interface should call this
             * function every time their contents change as the result of an operation,
             * like an insertion or a removal.
             *
             * Note: If the change is a deletion, this function must be called *before*
             * removing the contents, if it is an insertion, it must be called *after*
             * inserting the new contents.
             * @param change the type of change in the contents
             * @param start the starting offset of the change, in characters
             * @param end the end offset of the change, in characters
             */
            update_contents(change: AccessibleTextContentChange | null, start: number, end: number): void;
            /**
             * Updates the boundary of the selection.
             *
             * Implementations of the `GtkAccessibleText` interface should call this
             * function every time the selection has moved, in order to notify assistive
             * technologies.
             */
            update_selection_bound(): void;
            /**
             * Retrieves the text attributes inside the accessible object.
             *
             * Each attribute is composed by:
             *
             * - a range
             * - a name
             * - a value
             *
             * It is left to the implementation to determine the serialization format
             * of the value to a string.
             *
             * GTK provides support for various text attribute names and values, but
             * implementations of this interface are free to add their own attributes.
             *
             * If this function returns true, `n_ranges` will be set to a value
             * greater than or equal to one, `ranges` will be set to a newly
             * allocated array of [struct#Gtk.AccessibleTextRange].
             * @param offset the offset, in characters
             */
            vfunc_get_attributes(
                offset: number,
            ): [boolean, AccessibleTextRange[] | null, string[] | null, string[] | null];
            /**
             * Retrieves the position of the caret inside the accessible object.
             */
            vfunc_get_caret_position(): number;
            /**
             * Retrieve the current contents of the accessible object within
             * the given range.
             *
             * If `end` is `G_MAXUINT`, the end of the range is the full content
             * of the accessible object.
             * @param start the beginning of the range, in characters
             * @param end the end of the range, in characters
             */
            vfunc_get_contents(start: number, end: number): GLib.Bytes;
            /**
             * Retrieve the current contents of the accessible object starting
             * from the given offset, and using the given granularity.
             *
             * The `start` and `end` values contain the boundaries of the text.
             * @param offset the offset, in characters
             * @param granularity the granularity of the query
             */
            vfunc_get_contents_at(offset: number, granularity: AccessibleTextGranularity): [GLib.Bytes, number, number];
            /**
             * Retrieves the default text attributes inside the accessible object.
             *
             * Each attribute is composed by:
             *
             * - a name
             * - a value
             *
             * It is left to the implementation to determine the serialization format
             * of the value to a string.
             *
             * GTK provides support for various text attribute names and values, but
             * implementations of this interface are free to add their own attributes.
             */
            vfunc_get_default_attributes(): [string[] | null, string[] | null];
            /**
             * Obtains the extents of a range of text, in widget coordinates.
             * @param start the start offset, in characters
             * @param end the end offset, in characters, @extents (out caller-allocates): return location for the extents
             * @param extents
             */
            vfunc_get_extents(start: number, end: number, extents: Graphene.Rect): boolean;
            /**
             * Gets the text offset at a given point.
             * @param point a point in widget coordinates of @self
             */
            vfunc_get_offset(point: Graphene.Point): [boolean, number];
            /**
             * Retrieves the selection ranges in the accessible object.
             *
             * If this function returns true, `n_ranges` will be set to a value
             * greater than or equal to one, and `ranges` will be set to a newly
             * allocated array of [struct#Gtk.AccessibleTextRange].
             */
            vfunc_get_selection(): [boolean, AccessibleTextRange[] | null];
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Returns the size of a non-scrolling border around the
             * outside of the scrollable.
             *
             * An example for this would be treeview headers. GTK can use
             * this information to display overlaid graphics, like the
             * overshoot indication, at the right position.
             * @returns %TRUE if @border has been set
             */
            get_border(): [boolean, Border];
            /**
             * Retrieves the `GtkAdjustment` used for horizontal scrolling.
             * @returns horizontal `GtkAdjustment`.
             */
            get_hadjustment(): Adjustment | null;
            /**
             * Gets the horizontal `GtkScrollablePolicy`.
             * @returns The horizontal `GtkScrollablePolicy`.
             */
            get_hscroll_policy(): ScrollablePolicy;
            /**
             * Retrieves the `GtkAdjustment` used for vertical scrolling.
             * @returns vertical `GtkAdjustment`.
             */
            get_vadjustment(): Adjustment | null;
            /**
             * Gets the vertical `GtkScrollablePolicy`.
             * @returns The vertical `GtkScrollablePolicy`.
             */
            get_vscroll_policy(): ScrollablePolicy;
            /**
             * Sets the horizontal adjustment of the `GtkScrollable`.
             * @param hadjustment a `GtkAdjustment`
             */
            set_hadjustment(hadjustment?: Adjustment | null): void;
            /**
             * Sets the `GtkScrollablePolicy`.
             *
             * The policy determines whether horizontal scrolling should start
             * below the minimum width or below the natural width.
             * @param policy the horizontal `GtkScrollablePolicy`
             */
            set_hscroll_policy(policy: ScrollablePolicy | null): void;
            /**
             * Sets the vertical adjustment of the `GtkScrollable`.
             * @param vadjustment a `GtkAdjustment`
             */
            set_vadjustment(vadjustment?: Adjustment | null): void;
            /**
             * Sets the `GtkScrollablePolicy`.
             *
             * The policy determines whether vertical scrolling should start
             * below the minimum height or below the natural height.
             * @param policy the vertical `GtkScrollablePolicy`
             */
            set_vscroll_policy(policy: ScrollablePolicy | null): void;
            /**
             * Returns the size of a non-scrolling border around the
             * outside of the scrollable.
             *
             * An example for this would be treeview headers. GTK can use
             * this information to display overlaid graphics, like the
             * overshoot indication, at the right position.
             */
            vfunc_get_border(): [boolean, Border];
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ToggleButton {
            // Signal callback interfaces

            interface Toggled {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Button.ConstructorProps,
                    Accessible.ConstructorProps,
                    Actionable.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                active: boolean;
                group: ToggleButton;
            }
        }

        /**
         * A `GtkToggleButton` is a button which remains “pressed-in” when
         * clicked.
         *
         * Clicking again will cause the toggle button to return to its normal state.
         *
         * A toggle button is created by calling either [ctor`Gtk`.ToggleButton.new] or
         * [ctor`Gtk`.ToggleButton.new_with_label]. If using the former, it is advisable
         * to pack a widget, (such as a `GtkLabel` and/or a `GtkImage`), into the toggle
         * button’s container. (See [class`Gtk`.Button] for more information).
         *
         * The state of a `GtkToggleButton` can be set specifically using
         * [method`Gtk`.ToggleButton.set_active], and retrieved using
         * [method`Gtk`.ToggleButton.get_active].
         *
         * To simply switch the state of a toggle button, use
         * [method`Gtk`.ToggleButton.toggled].
         *
         * ## Grouping
         *
         * Toggle buttons can be grouped together, to form mutually exclusive
         * groups - only one of the buttons can be toggled at a time, and toggling
         * another one will switch the currently toggled one off.
         *
         * To add a `GtkToggleButton` to a group, use [method`Gtk`.ToggleButton.set_group].
         *
         * ## CSS nodes
         *
         * `GtkToggleButton` has a single CSS node with name button. To differentiate
         * it from a plain `GtkButton`, it gets the `.toggle` style class.
         *
         * ## Accessibility
         *
         * `GtkToggleButton` uses the %GTK_ACCESSIBLE_ROLE_TOGGLE_BUTTON role.
         *
         * ## Creating two `GtkToggleButton` widgets.
         *
         * ```c
         * static void
         * output_state (GtkToggleButton *source,
         *               gpointer         user_data)
         * {
         *   g_print ("Toggle button "%s" is active: %s",
         *            gtk_button_get_label (GTK_BUTTON (source)),
         *            gtk_toggle_button_get_active (source) ? "Yes" : "No");
         * }
         *
         * static void
         * make_toggles (void)
         * {
         *   GtkWidget *window, *toggle1, *toggle2;
         *   GtkWidget *box;
         *   const char *text;
         *
         *   window = gtk_window_new ();
         *   box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
         *
         *   text = "Hi, I’m toggle button one";
         *   toggle1 = gtk_toggle_button_new_with_label (text);
         *
         *   g_signal_connect (toggle1, "toggled",
         *                     G_CALLBACK (output_state),
         *                     NULL);
         *   gtk_box_append (GTK_BOX (box), toggle1);
         *
         *   text = "Hi, I’m toggle button two";
         *   toggle2 = gtk_toggle_button_new_with_label (text);
         *   g_signal_connect (toggle2, "toggled",
         *                     G_CALLBACK (output_state),
         *                     NULL);
         *   gtk_box_append (GTK_BOX (box), toggle2);
         *
         *   gtk_window_set_child (GTK_WINDOW (window), box);
         *   gtk_window_present (GTK_WINDOW (window));
         * }
         * ```
         */
        class ToggleButton extends Button implements Accessible, Actionable, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<ToggleButton>;

            // Properties

            /**
             * If the toggle button should be pressed in.
             */
            get active(): boolean;
            set active(val: boolean);
            /**
             * The toggle button whose group this widget belongs to.
             */
            set group(val: ToggleButton);

            // Constructors

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

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

            static ['new'](): ToggleButton;

            static new_with_label(label: string): ToggleButton;

            static new_with_mnemonic(label: string): ToggleButton;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'toggled', callback: (_source: this) => void): number;
            connect_after(signal: 'toggled', callback: (_source: this) => void): number;
            emit(signal: 'toggled'): void;

            // Virtual methods

            /**
             * Emits the ::toggled signal on the `GtkToggleButton`.
             */
            vfunc_toggled(): void;

            // Methods

            /**
             * Queries a `GtkToggleButton` and returns its current state.
             *
             * Returns %TRUE if the toggle button is pressed in and %FALSE
             * if it is raised.
             * @returns whether the button is pressed
             */
            get_active(): boolean;
            /**
             * Sets the status of the toggle button.
             *
             * Set to %TRUE if you want the `GtkToggleButton` to be “pressed in”,
             * and %FALSE to raise it.
             *
             * If the status of the button changes, this action causes the
             * [signal`Gtk`.ToggleButton::toggled] signal to be emitted.
             * @param is_active %TRUE or %FALSE.
             */
            set_active(is_active: boolean): void;
            /**
             * Adds `self` to the group of `group`.
             *
             * In a group of multiple toggle buttons, only one button can be active
             * at a time.
             *
             * Setting up groups in a cycle leads to undefined behavior.
             *
             * Note that the same effect can be achieved via the [iface`Gtk`.Actionable]
             * API, by using the same action with parameter type and state type 's'
             * for all buttons in the group, and giving each button its own target
             * value.
             * @param group another `GtkToggleButton` to   form a group with
             */
            set_group(group?: ToggleButton | null): void;
            /**
             * Emits the ::toggled signal on the `GtkToggleButton`.
             */
            toggled(): void;

            // Inherited properties
            /**
             * The name of the action with which this widget should be associated.
             */
            get action_name(): string;
            set action_name(val: string);
            /**
             * The name of the action with which this widget should be associated.
             */
            get actionName(): string;
            set actionName(val: string);
            /**
             * The target value of the actionable widget's action.
             */
            get action_target(): GLib.Variant;
            set action_target(val: GLib.Variant);
            /**
             * The target value of the actionable widget's action.
             */
            get actionTarget(): GLib.Variant;
            set actionTarget(val: GLib.Variant);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Gets the action name for `actionable`.
             * @returns the action name
             */
            get_action_name(): string | null;
            /**
             * Gets the current target value of `actionable`.
             * @returns the current target value
             */
            get_action_target_value(): GLib.Variant | null;
            /**
             * Specifies the name of the action with which this widget should be
             * associated.
             *
             * If `action_name` is %NULL then the widget will be unassociated from
             * any previous action.
             *
             * Usually this function is used when the widget is located (or will be
             * located) within the hierarchy of a `GtkApplicationWindow`.
             *
             * Names are of the form “win.save” or “app.quit” for actions on the
             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
             * associated with the window.
             * @param action_name an action name
             */
            set_action_name(action_name?: string | null): void;
            /**
             * Sets the target value of an actionable widget.
             *
             * If `target_value` is %NULL then the target value is unset.
             *
             * The target value has two purposes. First, it is used as the parameter
             * to activation of the action associated with the `GtkActionable` widget.
             * Second, it is used to determine if the widget should be rendered as
             * “active” — the widget is active if the state is equal to the given target.
             *
             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
             * with string state in a typical “radio button” situation. Each button
             * will be associated with the same action, but with a different target
             * value for that action. Clicking on a particular button will activate
             * the action with the target of that button, which will typically cause
             * the action’s state to change to that value. Since the action’s state
             * is now equal to the target value of the button, the button will now
             * be rendered as active (and the other buttons, with different targets,
             * rendered inactive).
             * @param target_value a [struct@GLib.Variant] to set as the target value
             */
            set_action_target_value(target_value?: GLib.Variant | null): void;
            /**
             * Sets the action-name and associated string target value of an
             * actionable widget.
             *
             * `detailed_action_name` is a string in the format accepted by
             * [func`Gio`.Action.parse_detailed_name].
             * @param detailed_action_name the detailed action name
             */
            set_detailed_action_name(detailed_action_name: string): void;
            /**
             * Gets the action name for `actionable`.
             */
            vfunc_get_action_name(): string | null;
            /**
             * Gets the current target value of `actionable`.
             */
            vfunc_get_action_target_value(): GLib.Variant | null;
            /**
             * Specifies the name of the action with which this widget should be
             * associated.
             *
             * If `action_name` is %NULL then the widget will be unassociated from
             * any previous action.
             *
             * Usually this function is used when the widget is located (or will be
             * located) within the hierarchy of a `GtkApplicationWindow`.
             *
             * Names are of the form “win.save” or “app.quit” for actions on the
             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
             * associated with the window.
             * @param action_name an action name
             */
            vfunc_set_action_name(action_name?: string | null): void;
            /**
             * Sets the target value of an actionable widget.
             *
             * If `target_value` is %NULL then the target value is unset.
             *
             * The target value has two purposes. First, it is used as the parameter
             * to activation of the action associated with the `GtkActionable` widget.
             * Second, it is used to determine if the widget should be rendered as
             * “active” — the widget is active if the state is equal to the given target.
             *
             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
             * with string state in a typical “radio button” situation. Each button
             * will be associated with the same action, but with a different target
             * value for that action. Clicking on a particular button will activate
             * the action with the target of that button, which will typically cause
             * the action’s state to change to that value. Since the action’s state
             * is now equal to the target value of the button, the button will now
             * be rendered as active (and the other buttons, with different targets,
             * rendered inactive).
             * @param target_value a [struct@GLib.Variant] to set as the target value
             */
            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace Tooltip {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * `GtkTooltip` is an object representing a widget tooltip.
         *
         * Basic tooltips can be realized simply by using
         * [method`Gtk`.Widget.set_tooltip_text] or
         * [method`Gtk`.Widget.set_tooltip_markup] without
         * any explicit tooltip object.
         *
         * When you need a tooltip with a little more fancy contents,
         * like adding an image, or you want the tooltip to have different
         * contents per `GtkTreeView` row or cell, you will have to do a
         * little more work:
         *
         * - Set the [property`Gtk`.Widget:has-tooltip] property to %TRUE.
         *   This will make GTK monitor the widget for motion and related events
         *   which are needed to determine when and where to show a tooltip.
         *
         * - Connect to the [signal`Gtk`.Widget::query-tooltip] signal.
         *   This signal will be emitted when a tooltip is supposed to be shown.
         *   One of the arguments passed to the signal handler is a `GtkTooltip`
         *   object. This is the object that we are about to display as a tooltip,
         *   and can be manipulated in your callback using functions like
         *   [method`Gtk`.Tooltip.set_icon]. There are functions for setting
         *   the tooltip’s markup, setting an image from a named icon, or even
         *   putting in a custom widget.
         *
         * - Return %TRUE from your ::query-tooltip handler. This causes the tooltip
         *   to be show. If you return %FALSE, it will not be shown.
         */
        class Tooltip extends GObject.Object {
            static $gtype: GObject.GType<Tooltip>;

            // Constructors

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

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

            // Methods

            /**
             * Replaces the widget packed into the tooltip with
             * `custom_widget`. `custom_widget` does not get destroyed when the tooltip goes
             * away.
             * By default a box with a `GtkImage` and `GtkLabel` is embedded in
             * the tooltip, which can be configured using gtk_tooltip_set_markup()
             * and gtk_tooltip_set_icon().
             * @param custom_widget a `GtkWidget`, or %NULL to unset the old custom widget.
             */
            set_custom(custom_widget?: Widget | null): void;
            /**
             * Sets the icon of the tooltip (which is in front of the text) to be
             * `paintable`.  If `paintable` is %NULL, the image will be hidden.
             * @param paintable a `GdkPaintable`
             */
            set_icon(paintable?: Gdk.Paintable | null): void;
            /**
             * Sets the icon of the tooltip (which is in front of the text)
             * to be the icon indicated by `gicon` with the size indicated
             * by `size`. If `gicon` is %NULL, the image will be hidden.
             * @param gicon a `GIcon` representing the icon
             */
            set_icon_from_gicon(gicon?: Gio.Icon | null): void;
            /**
             * Sets the icon of the tooltip (which is in front of the text) to be
             * the icon indicated by `icon_name` with the size indicated
             * by `size`.  If `icon_name` is %NULL, the image will be hidden.
             * @param icon_name an icon name
             */
            set_icon_from_icon_name(icon_name?: string | null): void;
            /**
             * Sets the text of the tooltip to be `markup`.
             *
             * The string must be marked up with Pango markup.
             * If `markup` is %NULL, the label will be hidden.
             * @param markup a string with Pango markup or %NLL
             */
            set_markup(markup?: string | null): void;
            /**
             * Sets the text of the tooltip to be `text`.
             *
             * If `text` is %NULL, the label will be hidden.
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param text a text string
             */
            set_text(text?: string | null): void;
            /**
             * Sets the area of the widget, where the contents of this tooltip apply,
             * to be `rect` (in widget coordinates).  This is especially useful for
             * properly setting tooltips on `GtkTreeView` rows and cells, `GtkIconViews`,
             * etc.
             *
             * For setting tooltips on `GtkTreeView`, please refer to the convenience
             * functions for this: gtk_tree_view_set_tooltip_row() and
             * gtk_tree_view_set_tooltip_cell().
             * @param rect a `GdkRectangle`
             */
            set_tip_area(rect: Gdk.Rectangle): void;
        }

        namespace TreeExpander {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                child: Widget;
                hide_expander: boolean;
                hideExpander: boolean;
                indent_for_depth: boolean;
                indentForDepth: boolean;
                indent_for_icon: boolean;
                indentForIcon: boolean;
                item: GObject.Object;
                list_row: TreeListRow;
                listRow: TreeListRow;
            }
        }

        /**
         * `GtkTreeExpander` is a widget that provides an expander for a list.
         *
         * It is typically placed as a bottommost child into a `GtkListView`
         * to allow users to expand and collapse children in a list with a
         * [class`Gtk`.TreeListModel]. `GtkTreeExpander` provides the common UI
         * elements, gestures and keybindings for this purpose.
         *
         * On top of this, the "listitem.expand", "listitem.collapse" and
         * "listitem.toggle-expand" actions are provided to allow adding custom
         * UI for managing expanded state.
         *
         * It is important to mention that you want to set the
         * [property`Gtk`.ListItem:focusable] property to FALSE when using this
         * widget, as you want the keyboard focus to be in the treexpander, and not
         * inside the list to make use of the keybindings.
         *
         * The `GtkTreeListModel` must be set to not be passthrough. Then it
         * will provide [class`Gtk`.TreeListRow] items which can be set via
         * [method`Gtk`.TreeExpander.set_list_row] on the expander.
         * The expander will then watch that row item automatically.
         * [method`Gtk`.TreeExpander.set_child] sets the widget that displays
         * the actual row contents.
         *
         * `GtkTreeExpander` can be modified with properties such as
         * [property`Gtk`.TreeExpander:indent-for-icon],
         * [property`Gtk`.TreeExpander:indent-for-depth], and
         * [property`Gtk`.TreeExpander:hide-expander] to achieve a different appearance.
         * This can even be done to influence individual rows, for example by binding
         * the [property`Gtk`.TreeExpander:hide-expander] property to the item count of
         * the model of the treelistrow, to hide the expander for rows without children,
         * even if the row is expandable.
         *
         * ## Shortcuts and Gestures
         *
         * `GtkTreeExpander` supports the following keyboard shortcuts:
         *
         * - <kbd>+</kbd> or <kbd>*</kbd> expands the expander.
         * - <kbd>-</kbd> or <kbd>/</kbd> collapses the expander.
         * - Left and right arrow keys, when combined with <kbd>Shift</kbd> or
         *   <kbd>Ctrl</kbd>+<kbd>Shift</kbd>, will expand or collapse, depending on
         *   the locale's text direction.
         * - <kbd>Ctrl</kbd>+<kbd>␣</kbd> toggles the expander state.
         *
         * The row can also expand on drag gestures.
         *
         * ## Actions
         *
         * `GtkTreeExpander` defines a set of built-in actions:
         *
         * - `listitem.expand` expands the expander if it can be expanded.
         * - `listitem.collapse` collapses the expander.
         * - `listitem.toggle-expand` tries to expand the expander if it was collapsed
         *   or collapses it if it was expanded.
         *
         * ## CSS nodes
         *
         * ```
         * treeexpander
         * ├── [indent]*
         * ├── [expander]
         * ╰── <child>
         * ```
         *
         * `GtkTreeExpander` has zero or one CSS nodes with the name "expander" that
         * should display the expander icon. The node will be `:checked` when it
         * is expanded. If the node is not expandable, an "indent" node will be
         * displayed instead.
         *
         * For every level of depth, another "indent" node is prepended.
         *
         * ## Accessibility
         *
         * Until GTK 4.10, `GtkTreeExpander` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
         *
         * Since GTK 4.12, `GtkTreeExpander` uses the `GTK_ACCESSIBLE_ROLE_BUTTON` role.
         * Toggling it will change the `GTK_ACCESSIBLE_STATE_EXPANDED` state.
         */
        class TreeExpander extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<TreeExpander>;

            // Properties

            /**
             * The child widget with the actual contents.
             */
            get child(): Widget;
            set child(val: Widget);
            /**
             * Whether the expander icon should be hidden in a GtkTreeListRow.
             * Note that this property simply hides the icon.  The actions and keybinding
             * (i.e. collapse and expand) are not affected by this property.
             *
             * A common use for this property would be to bind to the number of children in a
             * GtkTreeListRow's model in order to hide the expander when a row has no children.
             */
            get hide_expander(): boolean;
            set hide_expander(val: boolean);
            /**
             * Whether the expander icon should be hidden in a GtkTreeListRow.
             * Note that this property simply hides the icon.  The actions and keybinding
             * (i.e. collapse and expand) are not affected by this property.
             *
             * A common use for this property would be to bind to the number of children in a
             * GtkTreeListRow's model in order to hide the expander when a row has no children.
             */
            get hideExpander(): boolean;
            set hideExpander(val: boolean);
            /**
             * TreeExpander indents the child according to its depth.
             */
            get indent_for_depth(): boolean;
            set indent_for_depth(val: boolean);
            /**
             * TreeExpander indents the child according to its depth.
             */
            get indentForDepth(): boolean;
            set indentForDepth(val: boolean);
            /**
             * TreeExpander indents the child by the width of an expander-icon if it is not expandable.
             */
            get indent_for_icon(): boolean;
            set indent_for_icon(val: boolean);
            /**
             * TreeExpander indents the child by the width of an expander-icon if it is not expandable.
             */
            get indentForIcon(): boolean;
            set indentForIcon(val: boolean);
            /**
             * The item held by this expander's row.
             */
            get item(): GObject.Object;
            /**
             * The list row to track for expander state.
             */
            get list_row(): TreeListRow;
            set list_row(val: TreeListRow);
            /**
             * The list row to track for expander state.
             */
            get listRow(): TreeListRow;
            set listRow(val: TreeListRow);

            // Constructors

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

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

            static ['new'](): TreeExpander;

            // Methods

            /**
             * Gets the child widget displayed by `self`.
             * @returns The child displayed by @self
             */
            get_child(): Widget | null;
            /**
             * Gets whether the TreeExpander should be hidden in a GtkTreeListRow.
             * @returns TRUE if the expander icon should be hidden. Otherwise FALSE.
             */
            get_hide_expander(): boolean;
            /**
             * TreeExpander indents each level of depth with an additional indent.
             * @returns TRUE if the child should be indented . Otherwise FALSE.
             */
            get_indent_for_depth(): boolean;
            /**
             * TreeExpander indents the child by the width of an expander-icon if it is not expandable.
             * @returns TRUE if the child should be indented when not expandable. Otherwise FALSE.
             */
            get_indent_for_icon(): boolean;
            /**
             * Forwards the item set on the `GtkTreeListRow` that `self` is managing.
             *
             * This call is essentially equivalent to calling:
             *
             * ```c
             * gtk_tree_list_row_get_item (gtk_tree_expander_get_list_row (`self)`);
             * ```
             * @returns The item of the row
             */
            get_item<T = GObject.Object>(): T;
            /**
             * Gets the list row managed by `self`.
             * @returns The list row displayed by @self
             */
            get_list_row(): TreeListRow | null;
            /**
             * Sets the content widget to display.
             * @param child a `GtkWidget`
             */
            set_child(child?: Widget | null): void;
            /**
             * Sets whether the expander icon should be visible in a GtkTreeListRow.
             * @param hide_expander TRUE if the expander should be hidden. Otherwise FALSE.
             */
            set_hide_expander(hide_expander: boolean): void;
            /**
             * Sets if the TreeExpander should indent the child according to its depth.
             * @param indent_for_depth TRUE if the child should be indented. Otherwise FALSE.
             */
            set_indent_for_depth(indent_for_depth: boolean): void;
            /**
             * Sets if the TreeExpander should indent the child by the width of an expander-icon when it is not expandable.
             * @param indent_for_icon TRUE if the child should be indented without expander. Otherwise FALSE.
             */
            set_indent_for_icon(indent_for_icon: boolean): void;
            /**
             * Sets the tree list row that this expander should manage.
             * @param list_row a `GtkTreeListRow`
             */
            set_list_row(list_row?: TreeListRow | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace TreeListModel {
            // Constructor properties interface

            interface ConstructorProps<A extends GObject.Object = GObject.Object>
                extends GObject.Object.ConstructorProps,
                    Gio.ListModel.ConstructorProps {
                autoexpand: boolean;
                item_type: GObject.GType;
                itemType: GObject.GType;
                model: Gio.ListModel;
                n_items: number;
                nItems: number;
                passthrough: boolean;
            }
        }

        /**
         * `GtkTreeListModel` is a list model that can create child models on demand.
         */
        class TreeListModel<A extends GObject.Object = GObject.Object>
            extends GObject.Object
            implements Gio.ListModel<A>
        {
            static $gtype: GObject.GType<TreeListModel>;

            // Properties

            /**
             * If all rows should be expanded by default.
             */
            get autoexpand(): boolean;
            set autoexpand(val: boolean);
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get item_type(): GObject.GType;
            /**
             * The type of items. See [method`Gio`.ListModel.get_item_type].
             */
            get itemType(): GObject.GType;
            /**
             * The root model displayed.
             */
            get model(): Gio.ListModel;
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get n_items(): number;
            /**
             * The number of items. See [method`Gio`.ListModel.get_n_items].
             */
            get nItems(): number;
            /**
             * Gets whether the model is in passthrough mode.
             *
             * If %FALSE, the `GListModel` functions for this object return custom
             * [class`Gtk`.TreeListRow] objects. If %TRUE, the values of the child
             * models are pass through unmodified.
             */
            get passthrough(): boolean;

            // Constructors

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

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

            static ['new'](
                root: Gio.ListModel,
                passthrough: boolean,
                autoexpand: boolean,
                create_func: TreeListModelCreateModelFunc,
            ): TreeListModel;

            // Methods

            /**
             * Gets whether the model is set to automatically expand new rows
             * that get added.
             *
             * This can be either rows added by changes to the underlying
             * models or via [method`Gtk`.TreeListRow.set_expanded].
             * @returns %TRUE if the model is set to autoexpand
             */
            get_autoexpand(): boolean;
            /**
             * Gets the row item corresponding to the child at index `position` for
             * `self'`s root model.
             *
             * If `position` is greater than the number of children in the root model,
             * %NULL is returned.
             *
             * Do not confuse this function with [method`Gtk`.TreeListModel.get_row].
             * @param position position of the child to get
             * @returns the child in @position
             */
            get_child_row(position: number): TreeListRow | null;
            /**
             * Gets the root model that `self` was created with.
             * @returns the root model
             */
            get_model(): Gio.ListModel;
            /**
             * Gets whether the model is passing through original row items.
             *
             * If this function returns %FALSE, the `GListModel` functions for `self`
             * return custom `GtkTreeListRow` objects. You need to call
             * [method`Gtk`.TreeListRow.get_item] on these objects to get the original
             * item.
             *
             * If %TRUE, the values of the child models are passed through in their
             * original state. You then need to call [method`Gtk`.TreeListModel.get_row]
             * to get the custom `GtkTreeListRow`s.
             * @returns %TRUE if the model is passing through original row items
             */
            get_passthrough(): boolean;
            /**
             * Gets the row object for the given row.
             *
             * If `position` is greater than the number of items in `self,`
             * %NULL is returned.
             *
             * The row object can be used to expand and collapse rows as
             * well as to inspect its position in the tree. See its
             * documentation for details.
             *
             * This row object is persistent and will refer to the current
             * item as long as the row is present in `self,` independent of
             * other rows being added or removed.
             *
             * If `self` is set to not be passthrough, this function is
             * equivalent to calling g_list_model_get_item().
             *
             * Do not confuse this function with [method`Gtk`.TreeListModel.get_child_row].
             * @param position the position of the row to fetch
             * @returns The row item
             */
            get_row(position: number): TreeListRow | null;
            /**
             * Sets whether the model should autoexpand.
             *
             * If set to %TRUE, the model will recursively expand all rows that
             * get added to the model. This can be either rows added by changes
             * to the underlying models or via [method`Gtk`.TreeListRow.set_expanded].
             * @param autoexpand %TRUE to make the model autoexpand its rows
             */
            set_autoexpand(autoexpand: boolean): void;

            // Inherited methods
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             * @returns the #GType of the items contained in @list.
             */
            get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             * @returns the number of items in @list.
             */
            get_n_items(): number;
            /**
             * Get the item at `position`.
             *
             * If `position` is greater than the number of items in `list,` %NULL is
             * returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.
             *
             * This function is meant to be used by language bindings in place
             * of g_list_model_get_item().
             *
             * See also: g_list_model_get_n_items()
             * @param position the position of the item to fetch
             * @returns the object at @position.
             */
            get_item(position: number): A | null;
            /**
             * Emits the #GListModel::items-changed signal on `list`.
             *
             * This function should only be called by classes implementing
             * #GListModel. It has to be called after the internal representation
             * of `list` has been updated, because handlers connected to this signal
             * might query the new state of the list.
             *
             * Implementations must only make changes to the model (as visible to
             * its consumer) in places that will not cause problems for that
             * consumer.  For models that are driven directly by a write API (such
             * as #GListStore), changes can be reported in response to uses of that
             * API.  For models that represent remote data, changes should only be
             * made from a fresh mainloop dispatch.  It is particularly not
             * permitted to make changes in response to a call to the #GListModel
             * consumer API.
             *
             * Stated another way: in general, it is assumed that code making a
             * series of accesses to the model via the API, without returning to the
             * mainloop, and without calling other code, will continue to view the
             * same contents of the model.
             * @param position the position at which @list changed
             * @param removed the number of items removed
             * @param added the number of items added
             */
            items_changed(position: number, removed: number, added: number): void;
            /**
             * Get the item at `position`. If `position` is greater than the number of
             * items in `list,` %NULL is returned.
             *
             * %NULL is never returned for an index that is smaller than the length
             * of the list.  See g_list_model_get_n_items().
             *
             * The same #GObject instance may not appear more than once in a #GListModel.
             * @param position the position of the item to fetch
             */
            vfunc_get_item(position: number): A | null;
            /**
             * Gets the type of the items in `list`.
             *
             * All items returned from g_list_model_get_item() are of the type
             * returned by this function, or a subtype, or if the type is an
             * interface, they are an implementation of that interface.
             *
             * The item type of a #GListModel can not change during the life of the
             * model.
             */
            vfunc_get_item_type(): GObject.GType;
            /**
             * Gets the number of items in `list`.
             *
             * Depending on the model implementation, calling this function may be
             * less efficient than iterating the list with increasing values for
             * `position` until g_list_model_get_item() returns %NULL.
             */
            vfunc_get_n_items(): number;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace TreeListRow {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                children: Gio.ListModel;
                depth: number;
                expandable: boolean;
                expanded: boolean;
                item: GObject.Object;
            }
        }

        /**
         * `GtkTreeListRow` is used by `GtkTreeListModel` to represent items.
         *
         * It allows navigating the model as a tree and modify the state of rows.
         *
         * `GtkTreeListRow` instances are created by a `GtkTreeListModel` only
         * when the [property`Gtk`.TreeListModel:passthrough] property is not set.
         *
         * There are various support objects that can make use of `GtkTreeListRow`
         * objects, such as the [class`Gtk`.TreeExpander] widget that allows displaying
         * an icon to expand or collapse a row or [class`Gtk`.TreeListRowSorter] that
         * makes it possible to sort trees properly.
         */
        class TreeListRow extends GObject.Object {
            static $gtype: GObject.GType<TreeListRow>;

            // Properties

            /**
             * The model holding the row's children.
             */
            get children(): Gio.ListModel;
            /**
             * The depth in the tree of this row.
             */
            get depth(): number;
            /**
             * If this row can ever be expanded.
             */
            get expandable(): boolean;
            /**
             * If this row is currently expanded.
             */
            get expanded(): boolean;
            set expanded(val: boolean);
            /**
             * The item held in this row.
             */
            get item(): GObject.Object;

            // Constructors

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

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

            // Methods

            /**
             * If `self` is not expanded or `position` is greater than the
             * number of children, %NULL is returned.
             * @param position position of the child to get
             * @returns the child in @position
             */
            get_child_row(position: number): TreeListRow | null;
            /**
             * If the row is expanded, gets the model holding the children of `self`.
             *
             * This model is the model created by the
             * [callback`Gtk`.TreeListModelCreateModelFunc]
             * and contains the original items, no matter what value
             * [property`Gtk`.TreeListModel:passthrough] is set to.
             * @returns The model containing the children
             */
            get_children(): Gio.ListModel | null;
            /**
             * Gets the depth of this row.
             *
             * Rows that correspond to items in the root model have a depth
             * of zero, rows corresponding to items of models of direct children
             * of the root model have a depth of 1 and so on.
             *
             * The depth of a row never changes until the row is removed from its model
             * at which point it will forever return 0.
             * @returns The depth of this row
             */
            get_depth(): number;
            /**
             * Gets if a row is currently expanded.
             * @returns %TRUE if the row is expanded
             */
            get_expanded(): boolean;
            /**
             * Gets the item corresponding to this row,
             * @returns The item   of this row. This function is only marked as nullable for backwards   compatibility reasons.
             */
            get_item<T = GObject.Object>(): T;
            /**
             * Gets the row representing the parent for `self`.
             *
             * That is the row that would need to be collapsed
             * to make this row disappear.
             *
             * If `self` is a row corresponding to the root model,
             * %NULL is returned.
             *
             * The value returned by this function never changes
             * until the row is removed from its model at which point
             * it will forever return %NULL.
             * @returns The parent of @self
             */
            get_parent(): TreeListRow | null;
            /**
             * Returns the position in the `GtkTreeListModel` that `self` occupies
             * at the moment.
             * @returns The position in the model
             */
            get_position(): number;
            /**
             * Checks if a row can be expanded.
             *
             * This does not mean that the row is actually expanded,
             * this can be checked with [method`Gtk`.TreeListRow.get_expanded].
             *
             * If a row is expandable never changes until the row is removed
             * from its model at which point it will forever return %FALSE.
             * @returns %TRUE if the row is expandable
             */
            is_expandable(): boolean;
            /**
             * Expands or collapses a row.
             *
             * If a row is expanded, the model of calling the
             * [callback`Gtk`.TreeListModelCreateModelFunc] for the row's
             * item will be inserted after this row. If a row is collapsed,
             * those items will be removed from the model.
             *
             * If the row is not expandable, this function does nothing.
             * @param expanded %TRUE if the row should be expanded
             */
            set_expanded(expanded: boolean): void;
        }

        namespace TreeListRowSorter {
            // Constructor properties interface

            interface ConstructorProps extends Sorter.ConstructorProps {
                sorter: Sorter;
            }
        }

        /**
         * `GtkTreeListRowSorter` is a special-purpose sorter that will apply a given
         * sorter to the levels in a tree.
         *
         * Here is an example for setting up a column view with a tree model and
         * a `GtkTreeListSorter`:
         *
         * ```c
         * column_sorter = gtk_column_view_get_sorter (view);
         * sorter = gtk_tree_list_row_sorter_new (g_object_ref (column_sorter));
         * sort_model = gtk_sort_list_model_new (tree_model, sorter);
         * selection = gtk_single_selection_new (sort_model);
         * gtk_column_view_set_model (view, G_LIST_MODEL (selection));
         * ```
         */
        class TreeListRowSorter extends Sorter {
            static $gtype: GObject.GType<TreeListRowSorter>;

            // Properties

            /**
             * The underlying sorter
             */
            get sorter(): Sorter;
            set sorter(val: Sorter);

            // Constructors

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

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

            static ['new'](sorter?: Sorter | null): TreeListRowSorter;

            // Methods

            /**
             * Returns the sorter used by `self`.
             * @returns the sorter used
             */
            get_sorter(): Sorter | null;
            /**
             * Sets the sorter to use for items with the same parent.
             *
             * This sorter will be passed the [property`Gtk`.TreeListRow:item] of
             * the tree list rows passed to `self`.
             * @param sorter The sorter to use
             */
            set_sorter(sorter?: Sorter | null): void;
        }

        namespace TreeModelFilter {
            // Constructor properties interface

            interface ConstructorProps
                extends GObject.Object.ConstructorProps,
                    TreeDragSource.ConstructorProps,
                    TreeModel.ConstructorProps {
                child_model: TreeModel;
                childModel: TreeModel;
                virtual_root: TreePath;
                virtualRoot: TreePath;
            }
        }

        /**
         * A `GtkTreeModel` which hides parts of an underlying tree model
         *
         * A `GtkTreeModelFilter` is a tree model which wraps another tree model,
         * and can do the following things:
         *
         * - Filter specific rows, based on data from a “visible column”, a column
         *   storing booleans indicating whether the row should be filtered or not,
         *   or based on the return value of a “visible function”, which gets a
         *   model, iter and user_data and returns a boolean indicating whether the
         *   row should be filtered or not.
         *
         * - Modify the “appearance” of the model, using a modify function.
         *   This is extremely powerful and allows for just changing some
         *   values and also for creating a completely different model based
         *   on the given child model.
         *
         * - Set a different root node, also known as a “virtual root”. You can pass
         *   in a `GtkTreePath` indicating the root node for the filter at construction
         *   time.
         *
         * The basic API is similar to `GtkTreeModelSort`. For an example on its usage,
         * see the section on `GtkTreeModelSort`.
         *
         * When using `GtkTreeModelFilter`, it is important to realize that
         * `GtkTreeModelFilter` maintains an internal cache of all nodes which are
         * visible in its clients. The cache is likely to be a subtree of the tree
         * exposed by the child model. `GtkTreeModelFilter` will not cache the entire
         * child model when unnecessary to not compromise the caching mechanism
         * that is exposed by the reference counting scheme. If the child model
         * implements reference counting, unnecessary signals may not be emitted
         * because of reference counting rule 3, see the `GtkTreeModel`
         * documentation. (Note that e.g. `GtkTreeStore` does not implement
         * reference counting and will always emit all signals, even when
         * the receiving node is not visible).
         *
         * Because of this, limitations for possible visible functions do apply.
         * In general, visible functions should only use data or properties from
         * the node for which the visibility state must be determined, its siblings
         * or its parents. Usually, having a dependency on the state of any child
         * node is not possible, unless references are taken on these explicitly.
         * When no such reference exists, no signals may be received for these child
         * nodes (see reference counting rule number 3 in the `GtkTreeModel` section).
         *
         * Determining the visibility state of a given node based on the state
         * of its child nodes is a frequently occurring use case. Therefore,
         * `GtkTreeModelFilter` explicitly supports this. For example, when a node
         * does not have any children, you might not want the node to be visible.
         * As soon as the first row is added to the node’s child level (or the
         * last row removed), the node’s visibility should be updated.
         *
         * This introduces a dependency from the node on its child nodes. In order
         * to accommodate this, `GtkTreeModelFilter` must make sure the necessary
         * signals are received from the child model. This is achieved by building,
         * for all nodes which are exposed as visible nodes to `GtkTreeModelFilter`'s
         * clients, the child level (if any) and take a reference on the first node
         * in this level. Furthermore, for every row-inserted, row-changed or
         * row-deleted signal (also these which were not handled because the node
         * was not cached), `GtkTreeModelFilter` will check if the visibility state
         * of any parent node has changed.
         *
         * Beware, however, that this explicit support is limited to these two
         * cases. For example, if you want a node to be visible only if two nodes
         * in a child’s child level (2 levels deeper) are visible, you are on your
         * own. In this case, either rely on `GtkTreeStore` to emit all signals
         * because it does not implement reference counting, or for models that
         * do implement reference counting, obtain references on these child levels
         * yourself.
         */
        class TreeModelFilter extends GObject.Object implements TreeDragSource, TreeModel {
            static $gtype: GObject.GType<TreeModelFilter>;

            // Properties

            /**
             * The child model of the tree model filter.
             */
            get child_model(): TreeModel;
            /**
             * The child model of the tree model filter.
             */
            get childModel(): TreeModel;
            /**
             * The virtual root of the tree model filter.
             */
            get virtual_root(): TreePath;
            /**
             * The virtual root of the tree model filter.
             */
            get virtualRoot(): TreePath;

            // Constructors

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

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

            // Virtual methods

            vfunc_modify(child_model: TreeModel, iter: TreeIter, value: GObject.Value | any, column: number): void;
            vfunc_visible(child_model: TreeModel, iter: TreeIter): boolean;

            // Methods

            /**
             * This function should almost never be called. It clears the `filter`
             * of any cached iterators that haven’t been reffed with
             * gtk_tree_model_ref_node(). This might be useful if the child model
             * being filtered is static (and doesn’t change often) and there has been
             * a lot of unreffed access to nodes. As a side effect of this function,
             * all unreffed iters will be invalid.
             */
            clear_cache(): void;
            /**
             * Sets `filter_iter` to point to the row in `filter` that corresponds to the
             * row pointed at by `child_iter`.  If `filter_iter` was not set, %FALSE is
             * returned.
             * @param child_iter A valid `GtkTreeIter` pointing to a row on the child model.
             * @returns %TRUE, if @filter_iter was set, i.e. if @child_iter is a valid iterator pointing to a visible row in child model.
             */
            convert_child_iter_to_iter(child_iter: TreeIter): [boolean, TreeIter];
            /**
             * Converts `child_path` to a path relative to `filter`. That is, `child_path`
             * points to a path in the child model. The rerturned path will point to the
             * same row in the filtered model. If `child_path` isn’t a valid path on the
             * child model or points to a row which is not visible in `filter,` then %NULL
             * is returned.
             * @param child_path A `GtkTreePath` to convert.
             * @returns A newly allocated `GtkTreePath`
             */
            convert_child_path_to_path(child_path: TreePath): TreePath | null;
            /**
             * Sets `child_iter` to point to the row pointed to by `filter_iter`.
             * @param filter_iter A valid `GtkTreeIter` pointing to a row on @filter.
             */
            convert_iter_to_child_iter(filter_iter: TreeIter): TreeIter;
            /**
             * Converts `filter_path` to a path on the child model of `filter`. That is,
             * `filter_path` points to a location in `filter`. The returned path will
             * point to the same location in the model not being filtered. If `filter_path`
             * does not point to a location in the child model, %NULL is returned.
             * @param filter_path A `GtkTreePath` to convert.
             * @returns A newly allocated `GtkTreePath`
             */
            convert_path_to_child_path(filter_path: TreePath): TreePath | null;
            /**
             * Returns a pointer to the child model of `filter`.
             * @returns A pointer to a `GtkTreeModel`
             */
            get_model(): TreeModel;
            /**
             * Emits ::row_changed for each row in the child model, which causes
             * the filter to re-evaluate whether a row is visible or not.
             */
            refilter(): void;
            /**
             * With the `n_columns` and `types` parameters, you give an array of column
             * types for this model (which will be exposed to the parent model/view).
             * The `func,` `data` and `destroy` parameters are for specifying the modify
             * function. The modify function will get called for each
             * data access, the goal of the modify function is to return the data which
             * should be displayed at the location specified using the parameters of the
             * modify function.
             *
             * Note that gtk_tree_model_filter_set_modify_func()
             * can only be called once for a given filter model.
             * @param types The `GType`s of the columns.
             * @param func A `GtkTreeModelFilterModifyFunc`
             * @param destroy Destroy notifier of @data
             */
            set_modify_func(
                types: GObject.GType[],
                func: TreeModelFilterModifyFunc,
                destroy?: GLib.DestroyNotify | null,
            ): void;
            /**
             * Sets `column` of the child_model to be the column where `filter` should
             * look for visibility information. `columns` should be a column of type
             * %G_TYPE_BOOLEAN, where %TRUE means that a row is visible, and %FALSE
             * if not.
             *
             * Note that gtk_tree_model_filter_set_visible_func() or
             * gtk_tree_model_filter_set_visible_column() can only be called
             * once for a given filter model.
             * @param column A `int` which is the column containing the visible information
             */
            set_visible_column(column: number): void;
            /**
             * Sets the visible function used when filtering the `filter` to be `func`.
             * The function should return %TRUE if the given row should be visible and
             * %FALSE otherwise.
             *
             * If the condition calculated by the function changes over time (e.g.
             * because it depends on some global parameters), you must call
             * gtk_tree_model_filter_refilter() to keep the visibility information
             * of the model up-to-date.
             *
             * Note that `func` is called whenever a row is inserted, when it may still
             * be empty. The visible function should therefore take special care of empty
             * rows, like in the example below.
             *
             *
             * ```c
             * static gboolean
             * visible_func (GtkTreeModel *model,
             *               GtkTreeIter  *iter,
             *               gpointer      data)
             * {
             *   // Visible if row is non-empty and first column is “HI”
             *   char *str;
             *   gboolean visible = FALSE;
             *
             *   gtk_tree_model_get (model, iter, 0, &str, -1);
             *   if (str && strcmp (str, "HI") == 0)
             *     visible = TRUE;
             *   g_free (str);
             *
             *   return visible;
             * }
             * ```
             *
             *
             * Note that gtk_tree_model_filter_set_visible_func() or
             * gtk_tree_model_filter_set_visible_column() can only be called
             * once for a given filter model.
             * @param func A `GtkTreeModelFilterVisibleFunc`, the visible function
             * @param destroy Destroy notifier of @data
             */
            set_visible_func(func: TreeModelFilterVisibleFunc, destroy?: GLib.DestroyNotify | null): void;

            // Inherited methods
            /**
             * Asks the `GtkTreeDragSource` to delete the row at `path,` because
             * it was moved somewhere else via drag-and-drop. Returns %FALSE
             * if the deletion fails because `path` no longer exists, or for
             * some model-specific reason. Should robustly handle a `path` no
             * longer found in the model!
             * @param path row that was being dragged
             * @returns %TRUE if the row was successfully deleted
             */
            drag_data_delete(path: TreePath): boolean;
            /**
             * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
             * the row at `path`. Should robustly handle a `path` no
             * longer found in the model!
             * @param path row that was dragged
             * @returns a `GdkContentProvider` for the    given @path
             */
            drag_data_get(path: TreePath): Gdk.ContentProvider | null;
            /**
             * Asks the `GtkTreeDragSource` whether a particular row can be used as
             * the source of a DND operation. If the source doesn’t implement
             * this interface, the row is assumed draggable.
             * @param path row on which user is initiating a drag
             * @returns %TRUE if the row can be dragged
             */
            row_draggable(path: TreePath): boolean;
            /**
             * Asks the `GtkTreeDragSource` to delete the row at `path,` because
             * it was moved somewhere else via drag-and-drop. Returns %FALSE
             * if the deletion fails because `path` no longer exists, or for
             * some model-specific reason. Should robustly handle a `path` no
             * longer found in the model!
             * @param path row that was being dragged
             */
            vfunc_drag_data_delete(path: TreePath): boolean;
            /**
             * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
             * the row at `path`. Should robustly handle a `path` no
             * longer found in the model!
             * @param path row that was dragged
             */
            vfunc_drag_data_get(path: TreePath): Gdk.ContentProvider | null;
            /**
             * Asks the `GtkTreeDragSource` whether a particular row can be used as
             * the source of a DND operation. If the source doesn’t implement
             * this interface, the row is assumed draggable.
             * @param path row on which user is initiating a drag
             */
            vfunc_row_draggable(path: TreePath): boolean;
            /**
             * Creates a new `GtkTreeModel`, with `child_model` as the child_model
             * and `root` as the virtual root.
             * @param root A `GtkTreePath`
             * @returns A new `GtkTreeModel`.
             */
            filter_new(root?: TreePath | null): TreeModel;
            /**
             * Calls `func` on each node in model in a depth-first fashion.
             *
             * If `func` returns %TRUE, then the tree ceases to be walked,
             * and gtk_tree_model_foreach() returns.
             * @param func a function to be called on each row
             */
            foreach(func: TreeModelForeachFunc): void;
            /**
             * Returns the type of the column.
             * @param index_ the column index
             * @returns the type of the column
             */
            get_column_type(index_: number): GObject.GType;
            /**
             * Returns a set of flags supported by this interface.
             *
             * The flags are a bitwise combination of `GtkTreeModel`Flags.
             * The flags supported should not change during the lifetime
             * of the `tree_model`.
             * @returns the flags supported by this interface
             */
            get_flags(): TreeModelFlags;
            /**
             * Sets `iter` to a valid iterator pointing to `path`.
             *
             * If `path` does not exist, `iter` is set to an invalid
             * iterator and %FALSE is returned.
             * @param path the `GtkTreePath`
             * @returns %TRUE, if @iter was set
             */
            get_iter(path: TreePath): [boolean, TreeIter];
            /**
             * Initializes `iter` with the first iterator in the tree
             * (the one at the path "0").
             *
             * Returns %FALSE if the tree is empty, %TRUE otherwise.
             * @returns %TRUE, if @iter was set
             */
            get_iter_first(): [boolean, TreeIter];
            /**
             * Sets `iter` to a valid iterator pointing to `path_string,` if it
             * exists.
             *
             * Otherwise, `iter` is left invalid and %FALSE is returned.
             * @param path_string a string representation of a `GtkTreePath`
             * @returns %TRUE, if @iter was set
             */
            get_iter_from_string(path_string: string): [boolean, TreeIter];
            /**
             * Returns the number of columns supported by `tree_model`.
             * @returns the number of columns
             */
            get_n_columns(): number;
            /**
             * Returns a newly-created `GtkTreePath` referenced by `iter`.
             *
             * This path should be freed with gtk_tree_path_free().
             * @param iter the `GtkTreeIter`
             * @returns a newly-created `GtkTreePath`
             */
            get_path(iter: TreeIter): TreePath;
            /**
             * Generates a string representation of the iter.
             *
             * This string is a “:” separated list of numbers.
             * For example, “4:10:0:3” would be an acceptable
             * return value for this string.
             * @param iter a `GtkTreeIter`
             * @returns a newly-allocated string
             */
            get_string_from_iter(iter: TreeIter): string | null;
            /**
             * Initializes and sets `value` to that at `column`.
             *
             * When done with `value,` g_value_unset() needs to be called
             * to free any allocated memory.
             * @param iter the `GtkTreeIter`
             * @param column the column to lookup the value at
             */
            get_value(iter: TreeIter, column: number): unknown;
            /**
             * Sets `iter` to point to the first child of `parent`.
             *
             * If `parent` has no children, %FALSE is returned and `iter` is
             * set to be invalid. `parent` will remain a valid node after this
             * function has been called.
             *
             * If `parent` is %NULL returns the first node, equivalent to
             * `gtk_tree_model_get_iter_first (tree_model, iter);`
             * @param parent the `GtkTreeIter`
             * @returns %TRUE, if @iter has been set to the first child
             */
            iter_children(parent?: TreeIter | null): [boolean, TreeIter];
            /**
             * Returns %TRUE if `iter` has children, %FALSE otherwise.
             * @param iter the `GtkTreeIter` to test for children
             * @returns %TRUE if @iter has children
             */
            iter_has_child(iter: TreeIter): boolean;
            /**
             * Returns the number of children that `iter` has.
             *
             * As a special case, if `iter` is %NULL, then the number
             * of toplevel nodes is returned.
             * @param iter the `GtkTreeIter`
             * @returns the number of children of @iter
             */
            iter_n_children(iter?: TreeIter | null): number;
            /**
             * Sets `iter` to point to the node following it at the current level.
             *
             * If there is no next `iter,` %FALSE is returned and `iter` is set
             * to be invalid.
             * @param iter the `GtkTreeIter`
             * @returns %TRUE if @iter has been changed to the next node
             */
            iter_next(iter: TreeIter): boolean;
            /**
             * Sets `iter` to be the child of `parent,` using the given index.
             *
             * The first index is 0. If `n` is too big, or `parent` has no children,
             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
             * will remain a valid node after this function has been called. As a
             * special case, if `parent` is %NULL, then the `n-th` root node
             * is set.
             * @param parent the `GtkTreeIter` to get the child from
             * @param n the index of the desired child
             * @returns %TRUE, if @parent has an @n-th child
             */
            iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
            /**
             * Sets `iter` to be the parent of `child`.
             *
             * If `child` is at the toplevel, and doesn’t have a parent, then
             * `iter` is set to an invalid iterator and %FALSE is returned.
             * `child` will remain a valid node after this function has been
             * called.
             *
             * `iter` will be initialized before the lookup is performed, so `child`
             * and `iter` cannot point to the same memory location.
             * @param child the `GtkTreeIter`
             * @returns %TRUE, if @iter is set to the parent of @child
             */
            iter_parent(child: TreeIter): [boolean, TreeIter];
            /**
             * Sets `iter` to point to the previous node at the current level.
             *
             * If there is no previous `iter,` %FALSE is returned and `iter` is
             * set to be invalid.
             * @param iter the `GtkTreeIter`
             * @returns %TRUE if @iter has been changed to the previous node
             */
            iter_previous(iter: TreeIter): boolean;
            /**
             * Lets the tree ref the node.
             *
             * This is an optional method for models to implement.
             * To be more specific, models may ignore this call as it exists
             * primarily for performance reasons.
             *
             * This function is primarily meant as a way for views to let
             * caching models know when nodes are being displayed (and hence,
             * whether or not to cache that node). Being displayed means a node
             * is in an expanded branch, regardless of whether the node is currently
             * visible in the viewport. For example, a file-system based model
             * would not want to keep the entire file-hierarchy in memory,
             * just the sections that are currently being displayed by
             * every current view.
             *
             * A model should be expected to be able to get an iter independent
             * of its reffed state.
             * @param iter the `GtkTreeIter`
             */
            ref_node(iter: TreeIter): void;
            /**
             * Emits the ::row-changed signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-changed].
             * @param path a `GtkTreePath` pointing to the changed row
             * @param iter a valid `GtkTreeIter` pointing to the changed row
             */
            row_changed(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::row-deleted signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-deleted].
             *
             * This should be called by models after a row has been removed.
             * The location pointed to by `path` should be the location that
             * the row previously was at. It may not be a valid location anymore.
             *
             * Nodes that are deleted are not unreffed, this means that any
             * outstanding references on the deleted node should not be released.
             * @param path a `GtkTreePath` pointing to the previous location of   the deleted row
             */
            row_deleted(path: TreePath): void;
            /**
             * Emits the ::row-has-child-toggled signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-has-child-toggled].
             *
             * This should be called by models after the child
             * state of a node changes.
             * @param path a `GtkTreePath` pointing to the changed row
             * @param iter a valid `GtkTreeIter` pointing to the changed row
             */
            row_has_child_toggled(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::row-inserted signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-inserted].
             * @param path a `GtkTreePath` pointing to the inserted row
             * @param iter a valid `GtkTreeIter` pointing to the inserted row
             */
            row_inserted(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::rows-reordered signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::rows-reordered].
             *
             * This should be called by models when their rows have been
             * reordered.
             * @param path a `GtkTreePath` pointing to the tree node whose children   have been reordered
             * @param iter a valid `GtkTreeIter` pointing to the node   whose children have been reordered, or %NULL if the depth   of @path is 0
             * @param new_order an array of integers   mapping the current position of each child to its old   position before the re-ordering,   i.e. @new_order`[newpos] = oldpos`
             */
            rows_reordered(path: TreePath, iter: TreeIter | null, new_order: number[]): void;
            /**
             * Lets the tree unref the node.
             *
             * This is an optional method for models to implement.
             * To be more specific, models may ignore this call as it exists
             * primarily for performance reasons. For more information on what
             * this means, see gtk_tree_model_ref_node().
             *
             * Please note that nodes that are deleted are not unreffed.
             * @param iter the `GtkTreeIter`
             */
            unref_node(iter: TreeIter): void;
            /**
             * Returns the type of the column.
             * @param index_ the column index
             */
            vfunc_get_column_type(index_: number): GObject.GType;
            /**
             * Returns a set of flags supported by this interface.
             *
             * The flags are a bitwise combination of `GtkTreeModel`Flags.
             * The flags supported should not change during the lifetime
             * of the `tree_model`.
             */
            vfunc_get_flags(): TreeModelFlags;
            /**
             * Sets `iter` to a valid iterator pointing to `path`.
             *
             * If `path` does not exist, `iter` is set to an invalid
             * iterator and %FALSE is returned.
             * @param path the `GtkTreePath`
             */
            vfunc_get_iter(path: TreePath): [boolean, TreeIter];
            /**
             * Returns the number of columns supported by `tree_model`.
             */
            vfunc_get_n_columns(): number;
            /**
             * Returns a newly-created `GtkTreePath` referenced by `iter`.
             *
             * This path should be freed with gtk_tree_path_free().
             * @param iter the `GtkTreeIter`
             */
            vfunc_get_path(iter: TreeIter): TreePath;
            /**
             * Initializes and sets `value` to that at `column`.
             *
             * When done with `value,` g_value_unset() needs to be called
             * to free any allocated memory.
             * @param iter the `GtkTreeIter`
             * @param column the column to lookup the value at
             */
            vfunc_get_value(iter: TreeIter, column: number): unknown;
            /**
             * Sets `iter` to point to the first child of `parent`.
             *
             * If `parent` has no children, %FALSE is returned and `iter` is
             * set to be invalid. `parent` will remain a valid node after this
             * function has been called.
             *
             * If `parent` is %NULL returns the first node, equivalent to
             * `gtk_tree_model_get_iter_first (tree_model, iter);`
             * @param parent the `GtkTreeIter`
             */
            vfunc_iter_children(parent?: TreeIter | null): [boolean, TreeIter];
            /**
             * Returns %TRUE if `iter` has children, %FALSE otherwise.
             * @param iter the `GtkTreeIter` to test for children
             */
            vfunc_iter_has_child(iter: TreeIter): boolean;
            /**
             * Returns the number of children that `iter` has.
             *
             * As a special case, if `iter` is %NULL, then the number
             * of toplevel nodes is returned.
             * @param iter the `GtkTreeIter`
             */
            vfunc_iter_n_children(iter?: TreeIter | null): number;
            /**
             * Sets `iter` to point to the node following it at the current level.
             *
             * If there is no next `iter,` %FALSE is returned and `iter` is set
             * to be invalid.
             * @param iter the `GtkTreeIter`
             */
            vfunc_iter_next(iter: TreeIter): boolean;
            /**
             * Sets `iter` to be the child of `parent,` using the given index.
             *
             * The first index is 0. If `n` is too big, or `parent` has no children,
             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
             * will remain a valid node after this function has been called. As a
             * special case, if `parent` is %NULL, then the `n-th` root node
             * is set.
             * @param parent the `GtkTreeIter` to get the child from
             * @param n the index of the desired child
             */
            vfunc_iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
            /**
             * Sets `iter` to be the parent of `child`.
             *
             * If `child` is at the toplevel, and doesn’t have a parent, then
             * `iter` is set to an invalid iterator and %FALSE is returned.
             * `child` will remain a valid node after this function has been
             * called.
             *
             * `iter` will be initialized before the lookup is performed, so `child`
             * and `iter` cannot point to the same memory location.
             * @param child the `GtkTreeIter`
             */
            vfunc_iter_parent(child: TreeIter): [boolean, TreeIter];
            /**
             * Sets `iter` to point to the previous node at the current level.
             *
             * If there is no previous `iter,` %FALSE is returned and `iter` is
             * set to be invalid.
             * @param iter the `GtkTreeIter`
             */
            vfunc_iter_previous(iter: TreeIter): boolean;
            /**
             * Lets the tree ref the node.
             *
             * This is an optional method for models to implement.
             * To be more specific, models may ignore this call as it exists
             * primarily for performance reasons.
             *
             * This function is primarily meant as a way for views to let
             * caching models know when nodes are being displayed (and hence,
             * whether or not to cache that node). Being displayed means a node
             * is in an expanded branch, regardless of whether the node is currently
             * visible in the viewport. For example, a file-system based model
             * would not want to keep the entire file-hierarchy in memory,
             * just the sections that are currently being displayed by
             * every current view.
             *
             * A model should be expected to be able to get an iter independent
             * of its reffed state.
             * @param iter the `GtkTreeIter`
             */
            vfunc_ref_node(iter: TreeIter): void;
            /**
             * Emits the ::row-changed signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-changed].
             * @param path a `GtkTreePath` pointing to the changed row
             * @param iter a valid `GtkTreeIter` pointing to the changed row
             */
            vfunc_row_changed(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::row-deleted signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-deleted].
             *
             * This should be called by models after a row has been removed.
             * The location pointed to by `path` should be the location that
             * the row previously was at. It may not be a valid location anymore.
             *
             * Nodes that are deleted are not unreffed, this means that any
             * outstanding references on the deleted node should not be released.
             * @param path a `GtkTreePath` pointing to the previous location of   the deleted row
             */
            vfunc_row_deleted(path: TreePath): void;
            /**
             * Emits the ::row-has-child-toggled signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-has-child-toggled].
             *
             * This should be called by models after the child
             * state of a node changes.
             * @param path a `GtkTreePath` pointing to the changed row
             * @param iter a valid `GtkTreeIter` pointing to the changed row
             */
            vfunc_row_has_child_toggled(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::row-inserted signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-inserted].
             * @param path a `GtkTreePath` pointing to the inserted row
             * @param iter a valid `GtkTreeIter` pointing to the inserted row
             */
            vfunc_row_inserted(path: TreePath, iter: TreeIter): void;
            /**
             * Lets the tree unref the node.
             *
             * This is an optional method for models to implement.
             * To be more specific, models may ignore this call as it exists
             * primarily for performance reasons. For more information on what
             * this means, see gtk_tree_model_ref_node().
             *
             * Please note that nodes that are deleted are not unreffed.
             * @param iter the `GtkTreeIter`
             */
            vfunc_unref_node(iter: TreeIter): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace TreeModelSort {
            // Constructor properties interface

            interface ConstructorProps
                extends GObject.Object.ConstructorProps,
                    TreeDragSource.ConstructorProps,
                    TreeModel.ConstructorProps,
                    TreeSortable.ConstructorProps {
                model: TreeModel;
            }
        }

        /**
         * A GtkTreeModel which makes an underlying tree model sortable
         *
         * The `GtkTreeModelSort` is a model which implements the `GtkTreeSortable`
         * interface.  It does not hold any data itself, but rather is created with
         * a child model and proxies its data.  It has identical column types to
         * this child model, and the changes in the child are propagated.  The
         * primary purpose of this model is to provide a way to sort a different
         * model without modifying it. Note that the sort function used by
         * `GtkTreeModelSort` is not guaranteed to be stable.
         *
         * The use of this is best demonstrated through an example.  In the
         * following sample code we create two `GtkTreeView` widgets each with a
         * view of the same data.  As the model is wrapped here by a
         * `GtkTreeModelSort`, the two `GtkTreeView`s can each sort their
         * view of the data without affecting the other.  By contrast, if we
         * simply put the same model in each widget, then sorting the first would
         * sort the second.
         *
         * ## Using a `GtkTreeModelSort`
         *
         *
         * ```c
         * {
         *   GtkTreeView *tree_view1;
         *   GtkTreeView *tree_view2;
         *   GtkTreeModel *sort_model1;
         *   GtkTreeModel *sort_model2;
         *   GtkTreeModel *child_model;
         *
         *   // get the child model
         *   child_model = get_my_model ();
         *
         *   // Create the first tree
         *   sort_model1 = gtk_tree_model_sort_new_with_model (child_model);
         *   tree_view1 = gtk_tree_view_new_with_model (sort_model1);
         *
         *   // Create the second tree
         *   sort_model2 = gtk_tree_model_sort_new_with_model (child_model);
         *   tree_view2 = gtk_tree_view_new_with_model (sort_model2);
         *
         *   // Now we can sort the two models independently
         *   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model1),
         *                                         COLUMN_1, GTK_SORT_ASCENDING);
         *   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model2),
         *                                         COLUMN_1, GTK_SORT_DESCENDING);
         * }
         * ```
         *
         *
         * To demonstrate how to access the underlying child model from the sort
         * model, the next example will be a callback for the `GtkTreeSelection`
         * `GtkTreeSelection::changed` signal.  In this callback, we get a string
         * from COLUMN_1 of the model.  We then modify the string, find the same
         * selected row on the child model, and change the row there.
         *
         * ## Accessing the child model of in a selection changed callback
         *
         *
         * ```c
         * void
         * selection_changed (GtkTreeSelection *selection, gpointer data)
         * {
         *   GtkTreeModel *sort_model = NULL;
         *   GtkTreeModel *child_model;
         *   GtkTreeIter sort_iter;
         *   GtkTreeIter child_iter;
         *   char *some_data = NULL;
         *   char *modified_data;
         *
         *   // Get the current selected row and the model.
         *   if (! gtk_tree_selection_get_selected (selection,
         *                                          &sort_model,
         *                                          &sort_iter))
         *     return;
         *
         *   // Look up the current value on the selected row and get
         *   // a new value to change it to.
         *   gtk_tree_model_get (GTK_TREE_MODEL (sort_model), &sort_iter,
         *                       COLUMN_1, &some_data,
         *                       -1);
         *
         *   modified_data = change_the_data (some_data);
         *   g_free (some_data);
         *
         *   // Get an iterator on the child model, instead of the sort model.
         *   gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (sort_model),
         *                                                   &child_iter,
         *                                                   &sort_iter);
         *
         *   // Get the child model and change the value of the row. In this
         *   // example, the child model is a GtkListStore. It could be any other
         *   // type of model, though.
         *   child_model = gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (sort_model));
         *   gtk_list_store_set (GTK_LIST_STORE (child_model), &child_iter,
         *                       COLUMN_1, &modified_data,
         *                       -1);
         *   g_free (modified_data);
         * }
         * ```
         *
         */
        class TreeModelSort extends GObject.Object implements TreeDragSource, TreeModel, TreeSortable {
            static $gtype: GObject.GType<TreeModelSort>;

            // Properties

            /**
             * The model of the tree model sort.
             */
            get model(): TreeModel;

            // Constructors

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

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

            static new_with_model(child_model: TreeModel): TreeModelSort;

            // Methods

            /**
             * This function should almost never be called.  It clears the `tree_model_sort`
             * of any cached iterators that haven’t been reffed with
             * gtk_tree_model_ref_node().  This might be useful if the child model being
             * sorted is static (and doesn’t change often) and there has been a lot of
             * unreffed access to nodes.  As a side effect of this function, all unreffed
             * iters will be invalid.
             */
            clear_cache(): void;
            /**
             * Sets `sort_iter` to point to the row in `tree_model_sort` that corresponds to
             * the row pointed at by `child_iter`.  If `sort_iter` was not set, %FALSE
             * is returned.  Note: a boolean is only returned since 2.14.
             * @param child_iter A valid `GtkTreeIter` pointing to a row on the child model
             * @returns %TRUE, if @sort_iter was set, i.e. if @sort_iter is a valid iterator pointer to a visible row in the child model.
             */
            convert_child_iter_to_iter(child_iter: TreeIter): [boolean, TreeIter];
            /**
             * Converts `child_path` to a path relative to `tree_model_sort`.  That is,
             * `child_path` points to a path in the child model.  The returned path will
             * point to the same row in the sorted model.  If `child_path` isn’t a valid
             * path on the child model, then %NULL is returned.
             * @param child_path A `GtkTreePath` to convert
             * @returns A newly allocated `GtkTreePath`
             */
            convert_child_path_to_path(child_path: TreePath): TreePath | null;
            /**
             * Sets `child_iter` to point to the row pointed to by `sorted_iter`.
             * @param sorted_iter A valid `GtkTreeIter` pointing to a row on @tree_model_sort.
             */
            convert_iter_to_child_iter(sorted_iter: TreeIter): TreeIter;
            /**
             * Converts `sorted_path` to a path on the child model of `tree_model_sort`.
             * That is, `sorted_path` points to a location in `tree_model_sort`.  The
             * returned path will point to the same location in the model not being
             * sorted.  If `sorted_path` does not point to a location in the child model,
             * %NULL is returned.
             * @param sorted_path A `GtkTreePath` to convert
             * @returns A newly allocated `GtkTreePath`
             */
            convert_path_to_child_path(sorted_path: TreePath): TreePath | null;
            /**
             * Returns the model the `GtkTreeModelSort` is sorting.
             * @returns the "child model" being sorted
             */
            get_model(): TreeModel;
            /**
             * > This function is slow. Only use it for debugging and/or testing
             * > purposes.
             *
             * Checks if the given iter is a valid iter for this `GtkTreeModelSort`.
             * @param iter A `GtkTreeIter`
             * @returns %TRUE if the iter is valid, %FALSE if the iter is invalid.
             */
            iter_is_valid(iter: TreeIter): boolean;
            /**
             * This resets the default sort function to be in the “unsorted” state.  That
             * is, it is in the same order as the child model. It will re-sort the model
             * to be in the same order as the child model only if the `GtkTreeModelSort`
             * is in “unsorted” state.
             */
            reset_default_sort_func(): void;

            // Inherited methods
            /**
             * Asks the `GtkTreeDragSource` to delete the row at `path,` because
             * it was moved somewhere else via drag-and-drop. Returns %FALSE
             * if the deletion fails because `path` no longer exists, or for
             * some model-specific reason. Should robustly handle a `path` no
             * longer found in the model!
             * @param path row that was being dragged
             * @returns %TRUE if the row was successfully deleted
             */
            drag_data_delete(path: TreePath): boolean;
            /**
             * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
             * the row at `path`. Should robustly handle a `path` no
             * longer found in the model!
             * @param path row that was dragged
             * @returns a `GdkContentProvider` for the    given @path
             */
            drag_data_get(path: TreePath): Gdk.ContentProvider | null;
            /**
             * Asks the `GtkTreeDragSource` whether a particular row can be used as
             * the source of a DND operation. If the source doesn’t implement
             * this interface, the row is assumed draggable.
             * @param path row on which user is initiating a drag
             * @returns %TRUE if the row can be dragged
             */
            row_draggable(path: TreePath): boolean;
            /**
             * Asks the `GtkTreeDragSource` to delete the row at `path,` because
             * it was moved somewhere else via drag-and-drop. Returns %FALSE
             * if the deletion fails because `path` no longer exists, or for
             * some model-specific reason. Should robustly handle a `path` no
             * longer found in the model!
             * @param path row that was being dragged
             */
            vfunc_drag_data_delete(path: TreePath): boolean;
            /**
             * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
             * the row at `path`. Should robustly handle a `path` no
             * longer found in the model!
             * @param path row that was dragged
             */
            vfunc_drag_data_get(path: TreePath): Gdk.ContentProvider | null;
            /**
             * Asks the `GtkTreeDragSource` whether a particular row can be used as
             * the source of a DND operation. If the source doesn’t implement
             * this interface, the row is assumed draggable.
             * @param path row on which user is initiating a drag
             */
            vfunc_row_draggable(path: TreePath): boolean;
            /**
             * Creates a new `GtkTreeModel`, with `child_model` as the child_model
             * and `root` as the virtual root.
             * @param root A `GtkTreePath`
             * @returns A new `GtkTreeModel`.
             */
            filter_new(root?: TreePath | null): TreeModel;
            /**
             * Calls `func` on each node in model in a depth-first fashion.
             *
             * If `func` returns %TRUE, then the tree ceases to be walked,
             * and gtk_tree_model_foreach() returns.
             * @param func a function to be called on each row
             */
            foreach(func: TreeModelForeachFunc): void;
            /**
             * Returns the type of the column.
             * @param index_ the column index
             * @returns the type of the column
             */
            get_column_type(index_: number): GObject.GType;
            /**
             * Returns a set of flags supported by this interface.
             *
             * The flags are a bitwise combination of `GtkTreeModel`Flags.
             * The flags supported should not change during the lifetime
             * of the `tree_model`.
             * @returns the flags supported by this interface
             */
            get_flags(): TreeModelFlags;
            /**
             * Sets `iter` to a valid iterator pointing to `path`.
             *
             * If `path` does not exist, `iter` is set to an invalid
             * iterator and %FALSE is returned.
             * @param path the `GtkTreePath`
             * @returns %TRUE, if @iter was set
             */
            get_iter(path: TreePath): [boolean, TreeIter];
            /**
             * Initializes `iter` with the first iterator in the tree
             * (the one at the path "0").
             *
             * Returns %FALSE if the tree is empty, %TRUE otherwise.
             * @returns %TRUE, if @iter was set
             */
            get_iter_first(): [boolean, TreeIter];
            /**
             * Sets `iter` to a valid iterator pointing to `path_string,` if it
             * exists.
             *
             * Otherwise, `iter` is left invalid and %FALSE is returned.
             * @param path_string a string representation of a `GtkTreePath`
             * @returns %TRUE, if @iter was set
             */
            get_iter_from_string(path_string: string): [boolean, TreeIter];
            /**
             * Returns the number of columns supported by `tree_model`.
             * @returns the number of columns
             */
            get_n_columns(): number;
            /**
             * Returns a newly-created `GtkTreePath` referenced by `iter`.
             *
             * This path should be freed with gtk_tree_path_free().
             * @param iter the `GtkTreeIter`
             * @returns a newly-created `GtkTreePath`
             */
            get_path(iter: TreeIter): TreePath;
            /**
             * Generates a string representation of the iter.
             *
             * This string is a “:” separated list of numbers.
             * For example, “4:10:0:3” would be an acceptable
             * return value for this string.
             * @param iter a `GtkTreeIter`
             * @returns a newly-allocated string
             */
            get_string_from_iter(iter: TreeIter): string | null;
            /**
             * Initializes and sets `value` to that at `column`.
             *
             * When done with `value,` g_value_unset() needs to be called
             * to free any allocated memory.
             * @param iter the `GtkTreeIter`
             * @param column the column to lookup the value at
             */
            get_value(iter: TreeIter, column: number): unknown;
            /**
             * Sets `iter` to point to the first child of `parent`.
             *
             * If `parent` has no children, %FALSE is returned and `iter` is
             * set to be invalid. `parent` will remain a valid node after this
             * function has been called.
             *
             * If `parent` is %NULL returns the first node, equivalent to
             * `gtk_tree_model_get_iter_first (tree_model, iter);`
             * @param parent the `GtkTreeIter`
             * @returns %TRUE, if @iter has been set to the first child
             */
            iter_children(parent?: TreeIter | null): [boolean, TreeIter];
            /**
             * Returns %TRUE if `iter` has children, %FALSE otherwise.
             * @param iter the `GtkTreeIter` to test for children
             * @returns %TRUE if @iter has children
             */
            iter_has_child(iter: TreeIter): boolean;
            /**
             * Returns the number of children that `iter` has.
             *
             * As a special case, if `iter` is %NULL, then the number
             * of toplevel nodes is returned.
             * @param iter the `GtkTreeIter`
             * @returns the number of children of @iter
             */
            iter_n_children(iter?: TreeIter | null): number;
            /**
             * Sets `iter` to point to the node following it at the current level.
             *
             * If there is no next `iter,` %FALSE is returned and `iter` is set
             * to be invalid.
             * @param iter the `GtkTreeIter`
             * @returns %TRUE if @iter has been changed to the next node
             */
            iter_next(iter: TreeIter): boolean;
            /**
             * Sets `iter` to be the child of `parent,` using the given index.
             *
             * The first index is 0. If `n` is too big, or `parent` has no children,
             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
             * will remain a valid node after this function has been called. As a
             * special case, if `parent` is %NULL, then the `n-th` root node
             * is set.
             * @param parent the `GtkTreeIter` to get the child from
             * @param n the index of the desired child
             * @returns %TRUE, if @parent has an @n-th child
             */
            iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
            /**
             * Sets `iter` to be the parent of `child`.
             *
             * If `child` is at the toplevel, and doesn’t have a parent, then
             * `iter` is set to an invalid iterator and %FALSE is returned.
             * `child` will remain a valid node after this function has been
             * called.
             *
             * `iter` will be initialized before the lookup is performed, so `child`
             * and `iter` cannot point to the same memory location.
             * @param child the `GtkTreeIter`
             * @returns %TRUE, if @iter is set to the parent of @child
             */
            iter_parent(child: TreeIter): [boolean, TreeIter];
            /**
             * Sets `iter` to point to the previous node at the current level.
             *
             * If there is no previous `iter,` %FALSE is returned and `iter` is
             * set to be invalid.
             * @param iter the `GtkTreeIter`
             * @returns %TRUE if @iter has been changed to the previous node
             */
            iter_previous(iter: TreeIter): boolean;
            /**
             * Lets the tree ref the node.
             *
             * This is an optional method for models to implement.
             * To be more specific, models may ignore this call as it exists
             * primarily for performance reasons.
             *
             * This function is primarily meant as a way for views to let
             * caching models know when nodes are being displayed (and hence,
             * whether or not to cache that node). Being displayed means a node
             * is in an expanded branch, regardless of whether the node is currently
             * visible in the viewport. For example, a file-system based model
             * would not want to keep the entire file-hierarchy in memory,
             * just the sections that are currently being displayed by
             * every current view.
             *
             * A model should be expected to be able to get an iter independent
             * of its reffed state.
             * @param iter the `GtkTreeIter`
             */
            ref_node(iter: TreeIter): void;
            /**
             * Emits the ::row-changed signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-changed].
             * @param path a `GtkTreePath` pointing to the changed row
             * @param iter a valid `GtkTreeIter` pointing to the changed row
             */
            row_changed(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::row-deleted signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-deleted].
             *
             * This should be called by models after a row has been removed.
             * The location pointed to by `path` should be the location that
             * the row previously was at. It may not be a valid location anymore.
             *
             * Nodes that are deleted are not unreffed, this means that any
             * outstanding references on the deleted node should not be released.
             * @param path a `GtkTreePath` pointing to the previous location of   the deleted row
             */
            row_deleted(path: TreePath): void;
            /**
             * Emits the ::row-has-child-toggled signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-has-child-toggled].
             *
             * This should be called by models after the child
             * state of a node changes.
             * @param path a `GtkTreePath` pointing to the changed row
             * @param iter a valid `GtkTreeIter` pointing to the changed row
             */
            row_has_child_toggled(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::row-inserted signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-inserted].
             * @param path a `GtkTreePath` pointing to the inserted row
             * @param iter a valid `GtkTreeIter` pointing to the inserted row
             */
            row_inserted(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::rows-reordered signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::rows-reordered].
             *
             * This should be called by models when their rows have been
             * reordered.
             * @param path a `GtkTreePath` pointing to the tree node whose children   have been reordered
             * @param iter a valid `GtkTreeIter` pointing to the node   whose children have been reordered, or %NULL if the depth   of @path is 0
             * @param new_order an array of integers   mapping the current position of each child to its old   position before the re-ordering,   i.e. @new_order`[newpos] = oldpos`
             */
            rows_reordered(path: TreePath, iter: TreeIter | null, new_order: number[]): void;
            /**
             * Lets the tree unref the node.
             *
             * This is an optional method for models to implement.
             * To be more specific, models may ignore this call as it exists
             * primarily for performance reasons. For more information on what
             * this means, see gtk_tree_model_ref_node().
             *
             * Please note that nodes that are deleted are not unreffed.
             * @param iter the `GtkTreeIter`
             */
            unref_node(iter: TreeIter): void;
            /**
             * Returns the type of the column.
             * @param index_ the column index
             */
            vfunc_get_column_type(index_: number): GObject.GType;
            /**
             * Returns a set of flags supported by this interface.
             *
             * The flags are a bitwise combination of `GtkTreeModel`Flags.
             * The flags supported should not change during the lifetime
             * of the `tree_model`.
             */
            vfunc_get_flags(): TreeModelFlags;
            /**
             * Sets `iter` to a valid iterator pointing to `path`.
             *
             * If `path` does not exist, `iter` is set to an invalid
             * iterator and %FALSE is returned.
             * @param path the `GtkTreePath`
             */
            vfunc_get_iter(path: TreePath): [boolean, TreeIter];
            /**
             * Returns the number of columns supported by `tree_model`.
             */
            vfunc_get_n_columns(): number;
            /**
             * Returns a newly-created `GtkTreePath` referenced by `iter`.
             *
             * This path should be freed with gtk_tree_path_free().
             * @param iter the `GtkTreeIter`
             */
            vfunc_get_path(iter: TreeIter): TreePath;
            /**
             * Initializes and sets `value` to that at `column`.
             *
             * When done with `value,` g_value_unset() needs to be called
             * to free any allocated memory.
             * @param iter the `GtkTreeIter`
             * @param column the column to lookup the value at
             */
            vfunc_get_value(iter: TreeIter, column: number): unknown;
            /**
             * Sets `iter` to point to the first child of `parent`.
             *
             * If `parent` has no children, %FALSE is returned and `iter` is
             * set to be invalid. `parent` will remain a valid node after this
             * function has been called.
             *
             * If `parent` is %NULL returns the first node, equivalent to
             * `gtk_tree_model_get_iter_first (tree_model, iter);`
             * @param parent the `GtkTreeIter`
             */
            vfunc_iter_children(parent?: TreeIter | null): [boolean, TreeIter];
            /**
             * Returns %TRUE if `iter` has children, %FALSE otherwise.
             * @param iter the `GtkTreeIter` to test for children
             */
            vfunc_iter_has_child(iter: TreeIter): boolean;
            /**
             * Returns the number of children that `iter` has.
             *
             * As a special case, if `iter` is %NULL, then the number
             * of toplevel nodes is returned.
             * @param iter the `GtkTreeIter`
             */
            vfunc_iter_n_children(iter?: TreeIter | null): number;
            /**
             * Sets `iter` to point to the node following it at the current level.
             *
             * If there is no next `iter,` %FALSE is returned and `iter` is set
             * to be invalid.
             * @param iter the `GtkTreeIter`
             */
            vfunc_iter_next(iter: TreeIter): boolean;
            /**
             * Sets `iter` to be the child of `parent,` using the given index.
             *
             * The first index is 0. If `n` is too big, or `parent` has no children,
             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
             * will remain a valid node after this function has been called. As a
             * special case, if `parent` is %NULL, then the `n-th` root node
             * is set.
             * @param parent the `GtkTreeIter` to get the child from
             * @param n the index of the desired child
             */
            vfunc_iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
            /**
             * Sets `iter` to be the parent of `child`.
             *
             * If `child` is at the toplevel, and doesn’t have a parent, then
             * `iter` is set to an invalid iterator and %FALSE is returned.
             * `child` will remain a valid node after this function has been
             * called.
             *
             * `iter` will be initialized before the lookup is performed, so `child`
             * and `iter` cannot point to the same memory location.
             * @param child the `GtkTreeIter`
             */
            vfunc_iter_parent(child: TreeIter): [boolean, TreeIter];
            /**
             * Sets `iter` to point to the previous node at the current level.
             *
             * If there is no previous `iter,` %FALSE is returned and `iter` is
             * set to be invalid.
             * @param iter the `GtkTreeIter`
             */
            vfunc_iter_previous(iter: TreeIter): boolean;
            /**
             * Lets the tree ref the node.
             *
             * This is an optional method for models to implement.
             * To be more specific, models may ignore this call as it exists
             * primarily for performance reasons.
             *
             * This function is primarily meant as a way for views to let
             * caching models know when nodes are being displayed (and hence,
             * whether or not to cache that node). Being displayed means a node
             * is in an expanded branch, regardless of whether the node is currently
             * visible in the viewport. For example, a file-system based model
             * would not want to keep the entire file-hierarchy in memory,
             * just the sections that are currently being displayed by
             * every current view.
             *
             * A model should be expected to be able to get an iter independent
             * of its reffed state.
             * @param iter the `GtkTreeIter`
             */
            vfunc_ref_node(iter: TreeIter): void;
            /**
             * Emits the ::row-changed signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-changed].
             * @param path a `GtkTreePath` pointing to the changed row
             * @param iter a valid `GtkTreeIter` pointing to the changed row
             */
            vfunc_row_changed(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::row-deleted signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-deleted].
             *
             * This should be called by models after a row has been removed.
             * The location pointed to by `path` should be the location that
             * the row previously was at. It may not be a valid location anymore.
             *
             * Nodes that are deleted are not unreffed, this means that any
             * outstanding references on the deleted node should not be released.
             * @param path a `GtkTreePath` pointing to the previous location of   the deleted row
             */
            vfunc_row_deleted(path: TreePath): void;
            /**
             * Emits the ::row-has-child-toggled signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-has-child-toggled].
             *
             * This should be called by models after the child
             * state of a node changes.
             * @param path a `GtkTreePath` pointing to the changed row
             * @param iter a valid `GtkTreeIter` pointing to the changed row
             */
            vfunc_row_has_child_toggled(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::row-inserted signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-inserted].
             * @param path a `GtkTreePath` pointing to the inserted row
             * @param iter a valid `GtkTreeIter` pointing to the inserted row
             */
            vfunc_row_inserted(path: TreePath, iter: TreeIter): void;
            /**
             * Lets the tree unref the node.
             *
             * This is an optional method for models to implement.
             * To be more specific, models may ignore this call as it exists
             * primarily for performance reasons. For more information on what
             * this means, see gtk_tree_model_ref_node().
             *
             * Please note that nodes that are deleted are not unreffed.
             * @param iter the `GtkTreeIter`
             */
            vfunc_unref_node(iter: TreeIter): void;
            /**
             * Fills in `sort_column_id` and `order` with the current sort column and the
             * order. It returns %TRUE unless the `sort_column_id` is
             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
             * @returns %TRUE if the sort column is not one of the special sort   column ids.
             */
            get_sort_column_id(): [boolean, number, SortType];
            /**
             * Returns %TRUE if the model has a default sort function. This is used
             * primarily by GtkTreeViewColumns in order to determine if a model can
             * go back to the default state, or not.
             * @returns %TRUE, if the model has a default sort function
             */
            has_default_sort_func(): boolean;
            /**
             * Sets the default comparison function used when sorting to be `sort_func`.
             * If the current sort column id of `sortable` is
             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
             * this function.
             *
             * If `sort_func` is %NULL, then there will be no default comparison function.
             * This means that once the model  has been sorted, it can’t go back to the
             * default state. In this case, when the current sort column id of `sortable`
             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
             * @param sort_func The comparison function
             * @param destroy Destroy notifier of @user_data
             */
            set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
            /**
             * Sets the current sort column to be `sort_column_id`. The `sortable` will
             * resort itself to reflect this change, after emitting a
             * `GtkTreeSortable::sort-column-changed` signal. `sort_column_id` may either be
             * a regular column id, or one of the following special values:
             *
             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
             *   will be used, if it is set
             *
             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
             * @param sort_column_id the sort column id to set
             * @param order The sort order of the column
             */
            set_sort_column_id(sort_column_id: number, order: SortType | null): void;
            /**
             * Sets the comparison function used when sorting to be `sort_func`. If the
             * current sort column id of `sortable` is the same as `sort_column_id,` then
             * the model will sort using this function.
             * @param sort_column_id the sort column id to set the function for
             * @param sort_func The comparison function
             * @param destroy Destroy notifier of @user_data
             */
            set_sort_func(
                sort_column_id: number,
                sort_func: TreeIterCompareFunc,
                destroy?: GLib.DestroyNotify | null,
            ): void;
            /**
             * Emits a `GtkTreeSortable::sort-column-changed` signal on `sortable`.
             */
            sort_column_changed(): void;
            /**
             * Fills in `sort_column_id` and `order` with the current sort column and the
             * order. It returns %TRUE unless the `sort_column_id` is
             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
             */
            vfunc_get_sort_column_id(): [boolean, number, SortType];
            /**
             * Returns %TRUE if the model has a default sort function. This is used
             * primarily by GtkTreeViewColumns in order to determine if a model can
             * go back to the default state, or not.
             */
            vfunc_has_default_sort_func(): boolean;
            /**
             * Sets the default comparison function used when sorting to be `sort_func`.
             * If the current sort column id of `sortable` is
             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
             * this function.
             *
             * If `sort_func` is %NULL, then there will be no default comparison function.
             * This means that once the model  has been sorted, it can’t go back to the
             * default state. In this case, when the current sort column id of `sortable`
             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
             * @param sort_func The comparison function
             * @param destroy Destroy notifier of @user_data
             */
            vfunc_set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
            /**
             * Sets the current sort column to be `sort_column_id`. The `sortable` will
             * resort itself to reflect this change, after emitting a
             * `GtkTreeSortable::sort-column-changed` signal. `sort_column_id` may either be
             * a regular column id, or one of the following special values:
             *
             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
             *   will be used, if it is set
             *
             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
             * @param sort_column_id the sort column id to set
             * @param order The sort order of the column
             */
            vfunc_set_sort_column_id(sort_column_id: number, order: SortType): void;
            /**
             * Sets the comparison function used when sorting to be `sort_func`. If the
             * current sort column id of `sortable` is the same as `sort_column_id,` then
             * the model will sort using this function.
             * @param sort_column_id the sort column id to set the function for
             * @param sort_func The comparison function
             * @param destroy Destroy notifier of @user_data
             */
            vfunc_set_sort_func(
                sort_column_id: number,
                sort_func: TreeIterCompareFunc,
                destroy?: GLib.DestroyNotify | null,
            ): void;
            /**
             * Emits a `GtkTreeSortable::sort-column-changed` signal on `sortable`.
             */
            vfunc_sort_column_changed(): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace TreeSelection {
            // Signal callback interfaces

            interface Changed {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                mode: SelectionMode;
            }
        }

        /**
         * The selection object for GtkTreeView
         *
         * The `GtkTreeSelection` object is a helper object to manage the selection
         * for a `GtkTreeView` widget.  The `GtkTreeSelection` object is
         * automatically created when a new `GtkTreeView` widget is created, and
         * cannot exist independently of this widget.  The primary reason the
         * `GtkTreeSelection` objects exists is for cleanliness of code and API.
         * That is, there is no conceptual reason all these functions could not be
         * methods on the `GtkTreeView` widget instead of a separate function.
         *
         * The `GtkTreeSelection` object is gotten from a `GtkTreeView` by calling
         * gtk_tree_view_get_selection().  It can be manipulated to check the
         * selection status of the tree, as well as select and deselect individual
         * rows.  Selection is done completely view side.  As a result, multiple
         * views of the same model can have completely different selections.
         * Additionally, you cannot change the selection of a row on the model that
         * is not currently displayed by the view without expanding its parents
         * first.
         *
         * One of the important things to remember when monitoring the selection of
         * a view is that the `GtkTreeSelection`::changed signal is mostly a hint.
         * That is, it may only emit one signal when a range of rows is selected.
         * Additionally, it may on occasion emit a `GtkTreeSelection`::changed signal
         * when nothing has happened (mostly as a result of programmers calling
         * select_row on an already selected row).
         */
        class TreeSelection extends GObject.Object {
            static $gtype: GObject.GType<TreeSelection>;

            // Properties

            /**
             * Selection mode.
             * See gtk_tree_selection_set_mode() for more information on this property.
             */
            get mode(): SelectionMode;
            set mode(val: SelectionMode);

            // Constructors

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

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

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'changed', callback: (_source: this) => void): number;
            connect_after(signal: 'changed', callback: (_source: this) => void): number;
            emit(signal: 'changed'): void;

            // Methods

            /**
             * Returns the number of rows that have been selected in `tree`.
             * @returns The number of rows selected.
             */
            count_selected_rows(): number;
            /**
             * Gets the selection mode for `selection`. See
             * gtk_tree_selection_set_mode().
             * @returns the current selection mode
             */
            get_mode(): SelectionMode;
            /**
             * Sets `iter` to the currently selected node if `selection` is set to
             * %GTK_SELECTION_SINGLE or %GTK_SELECTION_BROWSE.  `iter` may be NULL if you
             * just want to test if `selection` has any selected nodes.  `model` is filled
             * with the current model as a convenience.  This function will not work if you
             * use `selection` is %GTK_SELECTION_MULTIPLE.
             * @returns TRUE, if there is a selected node.
             */
            get_selected(): [boolean, TreeModel | null, TreeIter | null];
            /**
             * Creates a list of path of all selected rows. Additionally, if you are
             * planning on modifying the model after calling this function, you may
             * want to convert the returned list into a list of `GtkTreeRowReference`s.
             * To do this, you can use gtk_tree_row_reference_new().
             *
             * To free the return value, use:
             *
             * ```c
             * g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
             * ```
             *
             * @returns A `GList` containing a `GtkTreePath` for each selected row.
             */
            get_selected_rows(): [TreePath[], TreeModel | null];
            /**
             * Returns the tree view associated with `selection`.
             * @returns A `GtkTreeView`
             */
            get_tree_view(): TreeView;
            /**
             * Returns %TRUE if the row at `iter` is currently selected.
             * @param iter A valid `GtkTreeIter`
             * @returns %TRUE, if @iter is selected
             */
            iter_is_selected(iter: TreeIter): boolean;
            /**
             * Returns %TRUE if the row pointed to by `path` is currently selected.  If `path`
             * does not point to a valid location, %FALSE is returned
             * @param path A `GtkTreePath` to check selection on.
             * @returns %TRUE if @path is selected.
             */
            path_is_selected(path: TreePath): boolean;
            /**
             * Selects all the nodes. `selection` must be set to %GTK_SELECTION_MULTIPLE
             * mode.
             */
            select_all(): void;
            /**
             * Selects the specified iterator.
             * @param iter The `GtkTreeIter` to be selected.
             */
            select_iter(iter: TreeIter): void;
            /**
             * Select the row at `path`.
             * @param path The `GtkTreePath` to be selected.
             */
            select_path(path: TreePath): void;
            /**
             * Selects a range of nodes, determined by `start_path` and `end_path` inclusive.
             * `selection` must be set to %GTK_SELECTION_MULTIPLE mode.
             * @param start_path The initial node of the range.
             * @param end_path The final node of the range.
             */
            select_range(start_path: TreePath, end_path: TreePath): void;
            /**
             * Calls a function for each selected node. Note that you cannot modify
             * the tree or selection from within this function. As a result,
             * gtk_tree_selection_get_selected_rows() might be more useful.
             * @param func The function to call for each selected node.
             */
            selected_foreach(func: TreeSelectionForeachFunc): void;
            /**
             * Sets the selection mode of the `selection`.  If the previous type was
             * %GTK_SELECTION_MULTIPLE, then the anchor is kept selected, if it was
             * previously selected.
             * @param type The selection mode
             */
            set_mode(type: SelectionMode | null): void;
            /**
             * Sets the selection function.
             *
             * If set, this function is called before any node is selected or unselected,
             * giving some control over which nodes are selected. The select function
             * should return %TRUE if the state of the node may be toggled, and %FALSE
             * if the state of the node should be left unchanged.
             * @param func The selection function. May be %NULL
             */
            set_select_function(func?: TreeSelectionFunc | null): void;
            /**
             * Unselects all the nodes.
             */
            unselect_all(): void;
            /**
             * Unselects the specified iterator.
             * @param iter The `GtkTreeIter` to be unselected.
             */
            unselect_iter(iter: TreeIter): void;
            /**
             * Unselects the row at `path`.
             * @param path The `GtkTreePath` to be unselected.
             */
            unselect_path(path: TreePath): void;
            /**
             * Unselects a range of nodes, determined by `start_path` and `end_path`
             * inclusive.
             * @param start_path The initial node of the range.
             * @param end_path The initial node of the range.
             */
            unselect_range(start_path: TreePath, end_path: TreePath): void;
        }

        namespace TreeStore {
            // Constructor properties interface

            interface ConstructorProps
                extends GObject.Object.ConstructorProps,
                    Buildable.ConstructorProps,
                    TreeDragDest.ConstructorProps,
                    TreeDragSource.ConstructorProps,
                    TreeModel.ConstructorProps,
                    TreeSortable.ConstructorProps {}
        }

        /**
         * A tree-like data structure that can be used with the [class`Gtk`.TreeView].
         *
         * The `GtkTreeStore` object is a list model for use with a `GtkTreeView`
         * widget. It implements the [iface`Gtk`.TreeModel] interface, and consequently,
         * can use all of the methods available there. It also implements the
         * [iface`Gtk`.TreeSortable] interface so it can be sorted by the view.
         * Finally, it also implements the tree [drag][iface`Gtk`.TreeDragSource]
         * and [drop][iface`Gtk`.TreeDragDest] interfaces.
         *
         * `GtkTreeStore` is deprecated since GTK 4.10, and should not be used in newly
         * written code. You should use [class`Gtk`.TreeListModel] for a tree-like model
         * object.
         *
         * ## GtkTreeStore as GtkBuildable
         *
         * The GtkTreeStore implementation of the `GtkBuildable` interface allows
         * to specify the model columns with a `<columns>` element that may contain
         * multiple `<column>` elements, each specifying one model column. The “type”
         * attribute specifies the data type for the column.
         *
         * An example of a UI Definition fragment for a tree store:
         *
         * ```xml
         * <object class="GtkTreeStore">
         *   <columns>
         *     <column type="gchararray"/>
         *     <column type="gchararray"/>
         *     <column type="gint"/>
         *   </columns>
         * </object>
         * ```
         */
        class TreeStore
            extends GObject.Object
            implements Buildable, TreeDragDest, TreeDragSource, TreeModel, TreeSortable
        {
            static $gtype: GObject.GType<TreeStore>;

            // Constructors

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

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

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

            // Methods

            /**
             * Appends a new row to `tree_store`.
             *
             * If `parent` is non-%NULL, then it will append the new row after the last
             * child of `parent,` otherwise it will append a row to the top level.
             *
             * The `iter` parameter will be changed to point to this new row. The row will
             * be empty after this function is called. To fill in values, you need to call
             * gtk_tree_store_set() or gtk_tree_store_set_value().
             * @param parent A valid `GtkTreeIter`
             */
            append(parent?: TreeIter | null): TreeIter;
            /**
             * Removes all rows from `tree_store`
             */
            clear(): void;
            /**
             * Creates a new row at `position`.
             *
             * If parent is non-%NULL, then the row will be made a child of `parent`.
             * Otherwise, the row will be created at the toplevel.
             *
             * If `position` is `-1` or is larger than the number of rows at that level,
             * then the new row will be inserted to the end of the list.
             *
             * The `iter` parameter will be changed to point to this new row. The row
             * will be empty after this function is called. To fill in values, you
             * need to call gtk_tree_store_set() or gtk_tree_store_set_value().
             * @param parent A valid `GtkTreeIter`
             * @param position position to insert the new row, or -1 for last
             */
            insert(parent: TreeIter | null, position: number): TreeIter;
            /**
             * Inserts a new row after `sibling`.
             *
             * If `sibling` is %NULL, then the row will be prepended to `parent’`s children.
             *
             * If `parent` and `sibling` are %NULL, then the row will be prepended to the
             * toplevel.
             *
             * If both `sibling` and `parent` are set, then `parent` must be the parent
             * of `sibling`. When `sibling` is set, `parent` is optional.
             *
             * The `iter` parameter will be changed to point to this new row. The row will
             * be empty after this function is called. To fill in values, you need to call
             * gtk_tree_store_set() or gtk_tree_store_set_value().
             * @param parent A valid `GtkTreeIter`
             * @param sibling A valid `GtkTreeIter`
             */
            insert_after(parent?: TreeIter | null, sibling?: TreeIter | null): TreeIter;
            /**
             * Inserts a new row before `sibling`.
             *
             * If `sibling` is %NULL, then the row will be appended to `parent’`s children.
             *
             * If `parent` and `sibling` are %NULL, then the row will be appended to the
             * toplevel.
             *
             * If both `sibling` and `parent` are set, then `parent` must be the parent
             * of `sibling`. When `sibling` is set, `parent` is optional.
             *
             * The `iter` parameter will be changed to point to this new row. The row will
             * be empty after this function is called. To fill in values, you need to call
             * gtk_tree_store_set() or gtk_tree_store_set_value().
             * @param parent A valid `GtkTreeIter`
             * @param sibling A valid `GtkTreeIter`
             */
            insert_before(parent?: TreeIter | null, sibling?: TreeIter | null): TreeIter;
            /**
             * A variant of gtk_tree_store_insert_with_values() which takes
             * the columns and values as two arrays, instead of varargs.
             *
             * This function is mainly intended for language bindings.
             * @param parent A valid `GtkTreeIter`
             * @param position position to insert the new row, or -1 for last
             * @param columns an array of column numbers
             * @param values an array of GValues
             */
            insert_with_values(
                parent: TreeIter | null,
                position: number,
                columns: number[],
                values: (GObject.Value | any)[],
            ): TreeIter | null;
            /**
             * Checks if `iter` is an ancestor of `descendant`.
             * @param iter A valid `GtkTreeIter`
             * @param descendant A valid `GtkTreeIter`
             * @returns true if @iter is an ancestor of @descendant, and false otherwise
             */
            is_ancestor(iter: TreeIter, descendant: TreeIter): boolean;
            /**
             * Returns the depth of the position pointed by the iterator
             *
             * The depth will be 0 for anything on the root level, 1 for anything down
             * a level, etc.
             * @param iter A valid `GtkTreeIter`
             * @returns The depth of the position pointed by the iterator
             */
            iter_depth(iter: TreeIter): number;
            /**
             * Checks if the given iter is a valid iter for this `GtkTreeStore`.
             *
             * This function is slow. Only use it for debugging and/or testing
             * purposes.
             * @param iter the iterator to check
             * @returns true if the iter is valid, and false otherwise
             */
            iter_is_valid(iter: TreeIter): boolean;
            /**
             * Moves `iter` in `tree_store` to the position after `position`.
             *
             * `iter` and `position` should be in the same level.
             *
             * Note that this function only works with unsorted stores.
             *
             * If `position` is %NULL, `iter` will be moved to the start of the level.
             * @param iter A `GtkTreeIter`.
             * @param position A `GtkTreeIter`.
             */
            move_after(iter: TreeIter, position?: TreeIter | null): void;
            /**
             * Moves `iter` in `tree_store` to the position before `position`.
             *
             * `iter` and `position` should be in the same level.
             *
             * Note that this function only works with unsorted stores.
             *
             * If `position` is %NULL, `iter` will be moved to the end of the level.
             * @param iter A `GtkTreeIter`
             * @param position A `GtkTreeIter`
             */
            move_before(iter: TreeIter, position?: TreeIter | null): void;
            /**
             * Prepends a new row to `tree_store`.
             *
             * If `parent` is non-%NULL, then it will prepend the new row before the first
             * child of `parent,` otherwise it will prepend a row to the top level. The
             * `iter` parameter will be changed to point to this new row.  The row will
             * be empty after this function is called. To fill in values, you need to
             * call gtk_tree_store_set() or gtk_tree_store_set_value().
             * @param parent A valid `GtkTreeIter`
             */
            prepend(parent?: TreeIter | null): TreeIter;
            /**
             * Removes `iter` from `tree_store`.
             *
             * After being removed, `iter` is set to the next valid row at that level, or
             * invalidated if it previously pointed to the last one.
             * @param iter A valid `GtkTreeIter`
             * @returns true if @iter is still valid, and false otherwise
             */
            remove(iter: TreeIter): boolean;
            /**
             * Sets the type of the columns in a tree store.
             *
             * This function is meant primarily for types that inherit from
             * `GtkTreeStore`, and should only be used when constructing a new
             * `GtkTreeStore`.
             *
             * This functions cannot be called after a row has been added,
             * or a method on the `GtkTreeModel` interface is called on the
             * tree store.
             * @param types An array of `GType` types, one for each column
             */
            set_column_types(types: GObject.GType[]): void;
            /**
             * Sets the data in the cell specified by `iter` and `column`.
             *
             * The type of `value` must be convertible to the type of the
             * column.
             * @param iter A valid `GtkTreeIter` for the row being modified
             * @param column column number to modify
             * @param value new value for the cell
             */
            set_value(iter: TreeIter, column: number, value: GObject.Value | any): void;
            /**
             * A variant of gtk_tree_store_set_valist() which takes
             * the columns and values as two arrays, instead of using variadic
             * arguments.
             *
             * This function is mainly intended for language bindings or in case
             * the number of columns to change is not known until run-time.
             * @param iter A valid `GtkTreeIter` for the row being modified
             * @param columns an array of column numbers
             * @param values an array of GValues
             */
            set(iter: TreeIter, columns: number[], values: (GObject.Value | any)[]): void;
            // Conflicted with GObject.Object.set
            set(...args: never[]): any;
            /**
             * Swaps `a` and `b` in the same level of `tree_store`.
             *
             * Note that this function only works with unsorted stores.
             * @param a A `GtkTreeIter`.
             * @param b Another `GtkTreeIter`.
             */
            swap(a: TreeIter, b: TreeIter): void;

            // Inherited methods
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Asks the `GtkTreeDragDest` to insert a row before the path `dest,`
             * deriving the contents of the row from `value`. If `dest` is
             * outside the tree so that inserting before it is impossible, %FALSE
             * will be returned. Also, %FALSE may be returned if the new row is
             * not created for some model-specific reason.  Should robustly handle
             * a `dest` no longer found in the model!
             * @param dest row to drop in front of
             * @param value data to drop
             * @returns whether a new row was created before position @dest
             */
            drag_data_received(dest: TreePath, value: GObject.Value | any): boolean;
            /**
             * Determines whether a drop is possible before the given `dest_path,`
             * at the same depth as `dest_path`. i.e., can we drop the data in
             * `value` at that location. `dest_path` does not have to
             * exist; the return value will almost certainly be %FALSE if the
             * parent of `dest_path` doesn’t exist, though.
             * @param dest_path destination row
             * @param value the data being dropped
             * @returns %TRUE if a drop is possible before @dest_path
             */
            row_drop_possible(dest_path: TreePath, value: GObject.Value | any): boolean;
            /**
             * Asks the `GtkTreeDragDest` to insert a row before the path `dest,`
             * deriving the contents of the row from `value`. If `dest` is
             * outside the tree so that inserting before it is impossible, %FALSE
             * will be returned. Also, %FALSE may be returned if the new row is
             * not created for some model-specific reason.  Should robustly handle
             * a `dest` no longer found in the model!
             * @param dest row to drop in front of
             * @param value data to drop
             */
            vfunc_drag_data_received(dest: TreePath, value: GObject.Value | any): boolean;
            /**
             * Determines whether a drop is possible before the given `dest_path,`
             * at the same depth as `dest_path`. i.e., can we drop the data in
             * `value` at that location. `dest_path` does not have to
             * exist; the return value will almost certainly be %FALSE if the
             * parent of `dest_path` doesn’t exist, though.
             * @param dest_path destination row
             * @param value the data being dropped
             */
            vfunc_row_drop_possible(dest_path: TreePath, value: GObject.Value | any): boolean;
            /**
             * Asks the `GtkTreeDragSource` to delete the row at `path,` because
             * it was moved somewhere else via drag-and-drop. Returns %FALSE
             * if the deletion fails because `path` no longer exists, or for
             * some model-specific reason. Should robustly handle a `path` no
             * longer found in the model!
             * @param path row that was being dragged
             * @returns %TRUE if the row was successfully deleted
             */
            drag_data_delete(path: TreePath): boolean;
            /**
             * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
             * the row at `path`. Should robustly handle a `path` no
             * longer found in the model!
             * @param path row that was dragged
             * @returns a `GdkContentProvider` for the    given @path
             */
            drag_data_get(path: TreePath): Gdk.ContentProvider | null;
            /**
             * Asks the `GtkTreeDragSource` whether a particular row can be used as
             * the source of a DND operation. If the source doesn’t implement
             * this interface, the row is assumed draggable.
             * @param path row on which user is initiating a drag
             * @returns %TRUE if the row can be dragged
             */
            row_draggable(path: TreePath): boolean;
            /**
             * Asks the `GtkTreeDragSource` to delete the row at `path,` because
             * it was moved somewhere else via drag-and-drop. Returns %FALSE
             * if the deletion fails because `path` no longer exists, or for
             * some model-specific reason. Should robustly handle a `path` no
             * longer found in the model!
             * @param path row that was being dragged
             */
            vfunc_drag_data_delete(path: TreePath): boolean;
            /**
             * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
             * the row at `path`. Should robustly handle a `path` no
             * longer found in the model!
             * @param path row that was dragged
             */
            vfunc_drag_data_get(path: TreePath): Gdk.ContentProvider | null;
            /**
             * Asks the `GtkTreeDragSource` whether a particular row can be used as
             * the source of a DND operation. If the source doesn’t implement
             * this interface, the row is assumed draggable.
             * @param path row on which user is initiating a drag
             */
            vfunc_row_draggable(path: TreePath): boolean;
            /**
             * Creates a new `GtkTreeModel`, with `child_model` as the child_model
             * and `root` as the virtual root.
             * @param root A `GtkTreePath`
             * @returns A new `GtkTreeModel`.
             */
            filter_new(root?: TreePath | null): TreeModel;
            /**
             * Calls `func` on each node in model in a depth-first fashion.
             *
             * If `func` returns %TRUE, then the tree ceases to be walked,
             * and gtk_tree_model_foreach() returns.
             * @param func a function to be called on each row
             */
            foreach(func: TreeModelForeachFunc): void;
            /**
             * Returns the type of the column.
             * @param index_ the column index
             * @returns the type of the column
             */
            get_column_type(index_: number): GObject.GType;
            /**
             * Returns a set of flags supported by this interface.
             *
             * The flags are a bitwise combination of `GtkTreeModel`Flags.
             * The flags supported should not change during the lifetime
             * of the `tree_model`.
             * @returns the flags supported by this interface
             */
            get_flags(): TreeModelFlags;
            /**
             * Sets `iter` to a valid iterator pointing to `path`.
             *
             * If `path` does not exist, `iter` is set to an invalid
             * iterator and %FALSE is returned.
             * @param path the `GtkTreePath`
             * @returns %TRUE, if @iter was set
             */
            get_iter(path: TreePath): [boolean, TreeIter];
            /**
             * Initializes `iter` with the first iterator in the tree
             * (the one at the path "0").
             *
             * Returns %FALSE if the tree is empty, %TRUE otherwise.
             * @returns %TRUE, if @iter was set
             */
            get_iter_first(): [boolean, TreeIter];
            /**
             * Sets `iter` to a valid iterator pointing to `path_string,` if it
             * exists.
             *
             * Otherwise, `iter` is left invalid and %FALSE is returned.
             * @param path_string a string representation of a `GtkTreePath`
             * @returns %TRUE, if @iter was set
             */
            get_iter_from_string(path_string: string): [boolean, TreeIter];
            /**
             * Returns the number of columns supported by `tree_model`.
             * @returns the number of columns
             */
            get_n_columns(): number;
            /**
             * Returns a newly-created `GtkTreePath` referenced by `iter`.
             *
             * This path should be freed with gtk_tree_path_free().
             * @param iter the `GtkTreeIter`
             * @returns a newly-created `GtkTreePath`
             */
            get_path(iter: TreeIter): TreePath;
            /**
             * Generates a string representation of the iter.
             *
             * This string is a “:” separated list of numbers.
             * For example, “4:10:0:3” would be an acceptable
             * return value for this string.
             * @param iter a `GtkTreeIter`
             * @returns a newly-allocated string
             */
            get_string_from_iter(iter: TreeIter): string | null;
            /**
             * Initializes and sets `value` to that at `column`.
             *
             * When done with `value,` g_value_unset() needs to be called
             * to free any allocated memory.
             * @param iter the `GtkTreeIter`
             * @param column the column to lookup the value at
             */
            get_value(iter: TreeIter, column: number): unknown;
            /**
             * Sets `iter` to point to the first child of `parent`.
             *
             * If `parent` has no children, %FALSE is returned and `iter` is
             * set to be invalid. `parent` will remain a valid node after this
             * function has been called.
             *
             * If `parent` is %NULL returns the first node, equivalent to
             * `gtk_tree_model_get_iter_first (tree_model, iter);`
             * @param parent the `GtkTreeIter`
             * @returns %TRUE, if @iter has been set to the first child
             */
            iter_children(parent?: TreeIter | null): [boolean, TreeIter];
            /**
             * Returns %TRUE if `iter` has children, %FALSE otherwise.
             * @param iter the `GtkTreeIter` to test for children
             * @returns %TRUE if @iter has children
             */
            iter_has_child(iter: TreeIter): boolean;
            /**
             * Returns the number of children that `iter` has.
             *
             * As a special case, if `iter` is %NULL, then the number
             * of toplevel nodes is returned.
             * @param iter the `GtkTreeIter`
             * @returns the number of children of @iter
             */
            iter_n_children(iter?: TreeIter | null): number;
            /**
             * Sets `iter` to point to the node following it at the current level.
             *
             * If there is no next `iter,` %FALSE is returned and `iter` is set
             * to be invalid.
             * @param iter the `GtkTreeIter`
             * @returns %TRUE if @iter has been changed to the next node
             */
            iter_next(iter: TreeIter): boolean;
            /**
             * Sets `iter` to be the child of `parent,` using the given index.
             *
             * The first index is 0. If `n` is too big, or `parent` has no children,
             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
             * will remain a valid node after this function has been called. As a
             * special case, if `parent` is %NULL, then the `n-th` root node
             * is set.
             * @param parent the `GtkTreeIter` to get the child from
             * @param n the index of the desired child
             * @returns %TRUE, if @parent has an @n-th child
             */
            iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
            /**
             * Sets `iter` to be the parent of `child`.
             *
             * If `child` is at the toplevel, and doesn’t have a parent, then
             * `iter` is set to an invalid iterator and %FALSE is returned.
             * `child` will remain a valid node after this function has been
             * called.
             *
             * `iter` will be initialized before the lookup is performed, so `child`
             * and `iter` cannot point to the same memory location.
             * @param child the `GtkTreeIter`
             * @returns %TRUE, if @iter is set to the parent of @child
             */
            iter_parent(child: TreeIter): [boolean, TreeIter];
            /**
             * Sets `iter` to point to the previous node at the current level.
             *
             * If there is no previous `iter,` %FALSE is returned and `iter` is
             * set to be invalid.
             * @param iter the `GtkTreeIter`
             * @returns %TRUE if @iter has been changed to the previous node
             */
            iter_previous(iter: TreeIter): boolean;
            /**
             * Lets the tree ref the node.
             *
             * This is an optional method for models to implement.
             * To be more specific, models may ignore this call as it exists
             * primarily for performance reasons.
             *
             * This function is primarily meant as a way for views to let
             * caching models know when nodes are being displayed (and hence,
             * whether or not to cache that node). Being displayed means a node
             * is in an expanded branch, regardless of whether the node is currently
             * visible in the viewport. For example, a file-system based model
             * would not want to keep the entire file-hierarchy in memory,
             * just the sections that are currently being displayed by
             * every current view.
             *
             * A model should be expected to be able to get an iter independent
             * of its reffed state.
             * @param iter the `GtkTreeIter`
             */
            ref_node(iter: TreeIter): void;
            /**
             * Emits the ::row-changed signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-changed].
             * @param path a `GtkTreePath` pointing to the changed row
             * @param iter a valid `GtkTreeIter` pointing to the changed row
             */
            row_changed(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::row-deleted signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-deleted].
             *
             * This should be called by models after a row has been removed.
             * The location pointed to by `path` should be the location that
             * the row previously was at. It may not be a valid location anymore.
             *
             * Nodes that are deleted are not unreffed, this means that any
             * outstanding references on the deleted node should not be released.
             * @param path a `GtkTreePath` pointing to the previous location of   the deleted row
             */
            row_deleted(path: TreePath): void;
            /**
             * Emits the ::row-has-child-toggled signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-has-child-toggled].
             *
             * This should be called by models after the child
             * state of a node changes.
             * @param path a `GtkTreePath` pointing to the changed row
             * @param iter a valid `GtkTreeIter` pointing to the changed row
             */
            row_has_child_toggled(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::row-inserted signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-inserted].
             * @param path a `GtkTreePath` pointing to the inserted row
             * @param iter a valid `GtkTreeIter` pointing to the inserted row
             */
            row_inserted(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::rows-reordered signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::rows-reordered].
             *
             * This should be called by models when their rows have been
             * reordered.
             * @param path a `GtkTreePath` pointing to the tree node whose children   have been reordered
             * @param iter a valid `GtkTreeIter` pointing to the node   whose children have been reordered, or %NULL if the depth   of @path is 0
             * @param new_order an array of integers   mapping the current position of each child to its old   position before the re-ordering,   i.e. @new_order`[newpos] = oldpos`
             */
            rows_reordered(path: TreePath, iter: TreeIter | null, new_order: number[]): void;
            /**
             * Lets the tree unref the node.
             *
             * This is an optional method for models to implement.
             * To be more specific, models may ignore this call as it exists
             * primarily for performance reasons. For more information on what
             * this means, see gtk_tree_model_ref_node().
             *
             * Please note that nodes that are deleted are not unreffed.
             * @param iter the `GtkTreeIter`
             */
            unref_node(iter: TreeIter): void;
            /**
             * Returns the type of the column.
             * @param index_ the column index
             */
            vfunc_get_column_type(index_: number): GObject.GType;
            /**
             * Returns a set of flags supported by this interface.
             *
             * The flags are a bitwise combination of `GtkTreeModel`Flags.
             * The flags supported should not change during the lifetime
             * of the `tree_model`.
             */
            vfunc_get_flags(): TreeModelFlags;
            /**
             * Sets `iter` to a valid iterator pointing to `path`.
             *
             * If `path` does not exist, `iter` is set to an invalid
             * iterator and %FALSE is returned.
             * @param path the `GtkTreePath`
             */
            vfunc_get_iter(path: TreePath): [boolean, TreeIter];
            /**
             * Returns the number of columns supported by `tree_model`.
             */
            vfunc_get_n_columns(): number;
            /**
             * Returns a newly-created `GtkTreePath` referenced by `iter`.
             *
             * This path should be freed with gtk_tree_path_free().
             * @param iter the `GtkTreeIter`
             */
            vfunc_get_path(iter: TreeIter): TreePath;
            /**
             * Initializes and sets `value` to that at `column`.
             *
             * When done with `value,` g_value_unset() needs to be called
             * to free any allocated memory.
             * @param iter the `GtkTreeIter`
             * @param column the column to lookup the value at
             */
            vfunc_get_value(iter: TreeIter, column: number): unknown;
            /**
             * Sets `iter` to point to the first child of `parent`.
             *
             * If `parent` has no children, %FALSE is returned and `iter` is
             * set to be invalid. `parent` will remain a valid node after this
             * function has been called.
             *
             * If `parent` is %NULL returns the first node, equivalent to
             * `gtk_tree_model_get_iter_first (tree_model, iter);`
             * @param parent the `GtkTreeIter`
             */
            vfunc_iter_children(parent?: TreeIter | null): [boolean, TreeIter];
            /**
             * Returns %TRUE if `iter` has children, %FALSE otherwise.
             * @param iter the `GtkTreeIter` to test for children
             */
            vfunc_iter_has_child(iter: TreeIter): boolean;
            /**
             * Returns the number of children that `iter` has.
             *
             * As a special case, if `iter` is %NULL, then the number
             * of toplevel nodes is returned.
             * @param iter the `GtkTreeIter`
             */
            vfunc_iter_n_children(iter?: TreeIter | null): number;
            /**
             * Sets `iter` to point to the node following it at the current level.
             *
             * If there is no next `iter,` %FALSE is returned and `iter` is set
             * to be invalid.
             * @param iter the `GtkTreeIter`
             */
            vfunc_iter_next(iter: TreeIter): boolean;
            /**
             * Sets `iter` to be the child of `parent,` using the given index.
             *
             * The first index is 0. If `n` is too big, or `parent` has no children,
             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
             * will remain a valid node after this function has been called. As a
             * special case, if `parent` is %NULL, then the `n-th` root node
             * is set.
             * @param parent the `GtkTreeIter` to get the child from
             * @param n the index of the desired child
             */
            vfunc_iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
            /**
             * Sets `iter` to be the parent of `child`.
             *
             * If `child` is at the toplevel, and doesn’t have a parent, then
             * `iter` is set to an invalid iterator and %FALSE is returned.
             * `child` will remain a valid node after this function has been
             * called.
             *
             * `iter` will be initialized before the lookup is performed, so `child`
             * and `iter` cannot point to the same memory location.
             * @param child the `GtkTreeIter`
             */
            vfunc_iter_parent(child: TreeIter): [boolean, TreeIter];
            /**
             * Sets `iter` to point to the previous node at the current level.
             *
             * If there is no previous `iter,` %FALSE is returned and `iter` is
             * set to be invalid.
             * @param iter the `GtkTreeIter`
             */
            vfunc_iter_previous(iter: TreeIter): boolean;
            /**
             * Lets the tree ref the node.
             *
             * This is an optional method for models to implement.
             * To be more specific, models may ignore this call as it exists
             * primarily for performance reasons.
             *
             * This function is primarily meant as a way for views to let
             * caching models know when nodes are being displayed (and hence,
             * whether or not to cache that node). Being displayed means a node
             * is in an expanded branch, regardless of whether the node is currently
             * visible in the viewport. For example, a file-system based model
             * would not want to keep the entire file-hierarchy in memory,
             * just the sections that are currently being displayed by
             * every current view.
             *
             * A model should be expected to be able to get an iter independent
             * of its reffed state.
             * @param iter the `GtkTreeIter`
             */
            vfunc_ref_node(iter: TreeIter): void;
            /**
             * Emits the ::row-changed signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-changed].
             * @param path a `GtkTreePath` pointing to the changed row
             * @param iter a valid `GtkTreeIter` pointing to the changed row
             */
            vfunc_row_changed(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::row-deleted signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-deleted].
             *
             * This should be called by models after a row has been removed.
             * The location pointed to by `path` should be the location that
             * the row previously was at. It may not be a valid location anymore.
             *
             * Nodes that are deleted are not unreffed, this means that any
             * outstanding references on the deleted node should not be released.
             * @param path a `GtkTreePath` pointing to the previous location of   the deleted row
             */
            vfunc_row_deleted(path: TreePath): void;
            /**
             * Emits the ::row-has-child-toggled signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-has-child-toggled].
             *
             * This should be called by models after the child
             * state of a node changes.
             * @param path a `GtkTreePath` pointing to the changed row
             * @param iter a valid `GtkTreeIter` pointing to the changed row
             */
            vfunc_row_has_child_toggled(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::row-inserted signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-inserted].
             * @param path a `GtkTreePath` pointing to the inserted row
             * @param iter a valid `GtkTreeIter` pointing to the inserted row
             */
            vfunc_row_inserted(path: TreePath, iter: TreeIter): void;
            /**
             * Lets the tree unref the node.
             *
             * This is an optional method for models to implement.
             * To be more specific, models may ignore this call as it exists
             * primarily for performance reasons. For more information on what
             * this means, see gtk_tree_model_ref_node().
             *
             * Please note that nodes that are deleted are not unreffed.
             * @param iter the `GtkTreeIter`
             */
            vfunc_unref_node(iter: TreeIter): void;
            /**
             * Fills in `sort_column_id` and `order` with the current sort column and the
             * order. It returns %TRUE unless the `sort_column_id` is
             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
             * @returns %TRUE if the sort column is not one of the special sort   column ids.
             */
            get_sort_column_id(): [boolean, number, SortType];
            /**
             * Returns %TRUE if the model has a default sort function. This is used
             * primarily by GtkTreeViewColumns in order to determine if a model can
             * go back to the default state, or not.
             * @returns %TRUE, if the model has a default sort function
             */
            has_default_sort_func(): boolean;
            /**
             * Sets the default comparison function used when sorting to be `sort_func`.
             * If the current sort column id of `sortable` is
             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
             * this function.
             *
             * If `sort_func` is %NULL, then there will be no default comparison function.
             * This means that once the model  has been sorted, it can’t go back to the
             * default state. In this case, when the current sort column id of `sortable`
             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
             * @param sort_func The comparison function
             * @param destroy Destroy notifier of @user_data
             */
            set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
            /**
             * Sets the current sort column to be `sort_column_id`. The `sortable` will
             * resort itself to reflect this change, after emitting a
             * `GtkTreeSortable::sort-column-changed` signal. `sort_column_id` may either be
             * a regular column id, or one of the following special values:
             *
             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
             *   will be used, if it is set
             *
             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
             * @param sort_column_id the sort column id to set
             * @param order The sort order of the column
             */
            set_sort_column_id(sort_column_id: number, order: SortType | null): void;
            /**
             * Sets the comparison function used when sorting to be `sort_func`. If the
             * current sort column id of `sortable` is the same as `sort_column_id,` then
             * the model will sort using this function.
             * @param sort_column_id the sort column id to set the function for
             * @param sort_func The comparison function
             * @param destroy Destroy notifier of @user_data
             */
            set_sort_func(
                sort_column_id: number,
                sort_func: TreeIterCompareFunc,
                destroy?: GLib.DestroyNotify | null,
            ): void;
            /**
             * Emits a `GtkTreeSortable::sort-column-changed` signal on `sortable`.
             */
            sort_column_changed(): void;
            /**
             * Fills in `sort_column_id` and `order` with the current sort column and the
             * order. It returns %TRUE unless the `sort_column_id` is
             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
             */
            vfunc_get_sort_column_id(): [boolean, number, SortType];
            /**
             * Returns %TRUE if the model has a default sort function. This is used
             * primarily by GtkTreeViewColumns in order to determine if a model can
             * go back to the default state, or not.
             */
            vfunc_has_default_sort_func(): boolean;
            /**
             * Sets the default comparison function used when sorting to be `sort_func`.
             * If the current sort column id of `sortable` is
             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
             * this function.
             *
             * If `sort_func` is %NULL, then there will be no default comparison function.
             * This means that once the model  has been sorted, it can’t go back to the
             * default state. In this case, when the current sort column id of `sortable`
             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
             * @param sort_func The comparison function
             * @param destroy Destroy notifier of @user_data
             */
            vfunc_set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
            /**
             * Sets the current sort column to be `sort_column_id`. The `sortable` will
             * resort itself to reflect this change, after emitting a
             * `GtkTreeSortable::sort-column-changed` signal. `sort_column_id` may either be
             * a regular column id, or one of the following special values:
             *
             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
             *   will be used, if it is set
             *
             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
             * @param sort_column_id the sort column id to set
             * @param order The sort order of the column
             */
            vfunc_set_sort_column_id(sort_column_id: number, order: SortType): void;
            /**
             * Sets the comparison function used when sorting to be `sort_func`. If the
             * current sort column id of `sortable` is the same as `sort_column_id,` then
             * the model will sort using this function.
             * @param sort_column_id the sort column id to set the function for
             * @param sort_func The comparison function
             * @param destroy Destroy notifier of @user_data
             */
            vfunc_set_sort_func(
                sort_column_id: number,
                sort_func: TreeIterCompareFunc,
                destroy?: GLib.DestroyNotify | null,
            ): void;
            /**
             * Emits a `GtkTreeSortable::sort-column-changed` signal on `sortable`.
             */
            vfunc_sort_column_changed(): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace TreeView {
            // Signal callback interfaces

            interface ColumnsChanged {
                (): void;
            }

            interface CursorChanged {
                (): void;
            }

            interface ExpandCollapseCursorRow {
                (object: boolean, p0: boolean, p1: boolean): boolean;
            }

            interface MoveCursor {
                (step: MovementStep, direction: number, extend: boolean, modify: boolean): boolean;
            }

            interface RowActivated {
                (path: TreePath, column?: TreeViewColumn | null): void;
            }

            interface RowCollapsed {
                (iter: TreeIter, path: TreePath): void;
            }

            interface RowExpanded {
                (iter: TreeIter, path: TreePath): void;
            }

            interface SelectAll {
                (): boolean;
            }

            interface SelectCursorParent {
                (): boolean;
            }

            interface SelectCursorRow {
                (object: boolean): boolean;
            }

            interface StartInteractiveSearch {
                (): boolean;
            }

            interface TestCollapseRow {
                (iter: TreeIter, path: TreePath): boolean;
            }

            interface TestExpandRow {
                (iter: TreeIter, path: TreePath): boolean;
            }

            interface ToggleCursorRow {
                (): boolean;
            }

            interface UnselectAll {
                (): boolean;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Scrollable.ConstructorProps {
                activate_on_single_click: boolean;
                activateOnSingleClick: boolean;
                enable_grid_lines: TreeViewGridLines;
                enableGridLines: TreeViewGridLines;
                enable_search: boolean;
                enableSearch: boolean;
                enable_tree_lines: boolean;
                enableTreeLines: boolean;
                expander_column: TreeViewColumn;
                expanderColumn: TreeViewColumn;
                fixed_height_mode: boolean;
                fixedHeightMode: boolean;
                headers_clickable: boolean;
                headersClickable: boolean;
                headers_visible: boolean;
                headersVisible: boolean;
                hover_expand: boolean;
                hoverExpand: boolean;
                hover_selection: boolean;
                hoverSelection: boolean;
                level_indentation: number;
                levelIndentation: number;
                model: TreeModel;
                reorderable: boolean;
                rubber_banding: boolean;
                rubberBanding: boolean;
                search_column: number;
                searchColumn: number;
                show_expanders: boolean;
                showExpanders: boolean;
                tooltip_column: number;
                tooltipColumn: number;
            }
        }

        /**
         * A widget for displaying both trees and lists
         *
         * Widget that displays any object that implements the [iface`Gtk`.TreeModel] interface.
         *
         * Please refer to the [tree widget conceptual overview](section-tree-widget.html)
         * for an overview of all the objects and data types related to the tree
         * widget and how they work together.
         *
         * ## Coordinate systems in GtkTreeView API
         *
         * Several different coordinate systems are exposed in the `GtkTreeView` API.
         * These are:
         *
         * ![](tree-view-coordinates.png)
         *
         * - Widget coordinates: Coordinates relative to the widget (usually `widget->window`).
         *
         * - Bin window coordinates: Coordinates relative to the window that GtkTreeView renders to.
         *
         * - Tree coordinates: Coordinates relative to the entire scrollable area of GtkTreeView. These
         *   coordinates start at (0, 0) for row 0 of the tree.
         *
         * Several functions are available for converting between the different
         * coordinate systems.  The most common translations are between widget and bin
         * window coordinates and between bin window and tree coordinates. For the
         * former you can use [method`Gtk`.TreeView.convert_widget_to_bin_window_coords]
         * (and vice versa), for the latter [method`Gtk`.TreeView.convert_bin_window_to_tree_coords]
         * (and vice versa).
         *
         * ## `GtkTreeView` as `GtkBuildable`
         *
         * The `GtkTreeView` implementation of the `GtkBuildable` interface accepts
         * [class`Gtk`.TreeViewColumn] objects as `<child>` elements and exposes the
         * internal [class`Gtk`.TreeSelection] in UI definitions.
         *
         * An example of a UI definition fragment with `GtkTreeView`:
         *
         * ```xml
         * <object class="GtkTreeView" id="treeview">
         *   <property name="model">liststore1</property>
         *   <child>
         *     <object class="GtkTreeViewColumn" id="test-column">
         *       <property name="title">Test</property>
         *       <child>
         *         <object class="GtkCellRendererText" id="test-renderer"/>
         *         <attributes>
         *           <attribute name="text">1</attribute>
         *         </attributes>
         *       </child>
         *     </object>
         *   </child>
         *   <child internal-child="selection">
         *     <object class="GtkTreeSelection" id="selection">
         *       <signal name="changed" handler="on_treeview_selection_changed"/>
         *     </object>
         *   </child>
         * </object>
         * ```
         *
         * ## CSS nodes
         *
         * ```
         * treeview.view
         * ├── header
         * │   ├── button
         * │   │   ╰── [sort-indicator]
         * ┊   ┊
         * │   ╰── button
         * │       ╰── [sort-indicator]
         * │
         * ├── [rubberband]
         * ╰── [dndtarget]
         * ```
         *
         * `GtkTreeView` has a main CSS node with name `treeview` and style class `.view`.
         * It has a subnode with name `header`, which is the parent for all the column
         * header widgets' CSS nodes.
         *
         * Each column header consists of a `button`, which among other content, has a
         * child with name `sort-indicator`, which carries the `.ascending` or `.descending`
         * style classes when the column header should show a sort indicator. The CSS
         * is expected to provide a suitable image using the `-gtk-icon-source` property.
         *
         * For rubberband selection, a subnode with name `rubberband` is used.
         *
         * For the drop target location during DND, a subnode with name `dndtarget` is used.
         */
        class TreeView extends Widget implements Accessible, Buildable, ConstraintTarget, Scrollable {
            static $gtype: GObject.GType<TreeView>;

            // Properties

            /**
             * The activate-on-single-click property specifies whether the "row-activated" signal
             * will be emitted after a single click.
             */
            get activate_on_single_click(): boolean;
            set activate_on_single_click(val: boolean);
            /**
             * The activate-on-single-click property specifies whether the "row-activated" signal
             * will be emitted after a single click.
             */
            get activateOnSingleClick(): boolean;
            set activateOnSingleClick(val: boolean);
            get enable_grid_lines(): TreeViewGridLines;
            set enable_grid_lines(val: TreeViewGridLines);
            get enableGridLines(): TreeViewGridLines;
            set enableGridLines(val: TreeViewGridLines);
            get enable_search(): boolean;
            set enable_search(val: boolean);
            get enableSearch(): boolean;
            set enableSearch(val: boolean);
            get enable_tree_lines(): boolean;
            set enable_tree_lines(val: boolean);
            get enableTreeLines(): boolean;
            set enableTreeLines(val: boolean);
            get expander_column(): TreeViewColumn;
            set expander_column(val: TreeViewColumn);
            get expanderColumn(): TreeViewColumn;
            set expanderColumn(val: TreeViewColumn);
            /**
             * Setting the ::fixed-height-mode property to %TRUE speeds up
             * `GtkTreeView` by assuming that all rows have the same height.
             * Only enable this option if all rows are the same height.
             * Please see gtk_tree_view_set_fixed_height_mode() for more
             * information on this option.
             */
            get fixed_height_mode(): boolean;
            set fixed_height_mode(val: boolean);
            /**
             * Setting the ::fixed-height-mode property to %TRUE speeds up
             * `GtkTreeView` by assuming that all rows have the same height.
             * Only enable this option if all rows are the same height.
             * Please see gtk_tree_view_set_fixed_height_mode() for more
             * information on this option.
             */
            get fixedHeightMode(): boolean;
            set fixedHeightMode(val: boolean);
            get headers_clickable(): boolean;
            set headers_clickable(val: boolean);
            get headersClickable(): boolean;
            set headersClickable(val: boolean);
            get headers_visible(): boolean;
            set headers_visible(val: boolean);
            get headersVisible(): boolean;
            set headersVisible(val: boolean);
            /**
             * Enables or disables the hover expansion mode of `tree_view`.
             * Hover expansion makes rows expand or collapse if the pointer moves
             * over them.
             *
             * This mode is primarily intended for treeviews in popups, e.g.
             * in `GtkComboBox` or `GtkEntryCompletion`.
             */
            get hover_expand(): boolean;
            set hover_expand(val: boolean);
            /**
             * Enables or disables the hover expansion mode of `tree_view`.
             * Hover expansion makes rows expand or collapse if the pointer moves
             * over them.
             *
             * This mode is primarily intended for treeviews in popups, e.g.
             * in `GtkComboBox` or `GtkEntryCompletion`.
             */
            get hoverExpand(): boolean;
            set hoverExpand(val: boolean);
            /**
             * Enables or disables the hover selection mode of `tree_view`.
             * Hover selection makes the selected row follow the pointer.
             * Currently, this works only for the selection modes
             * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
             *
             * This mode is primarily intended for treeviews in popups, e.g.
             * in `GtkComboBox` or `GtkEntryCompletion`.
             */
            get hover_selection(): boolean;
            set hover_selection(val: boolean);
            /**
             * Enables or disables the hover selection mode of `tree_view`.
             * Hover selection makes the selected row follow the pointer.
             * Currently, this works only for the selection modes
             * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
             *
             * This mode is primarily intended for treeviews in popups, e.g.
             * in `GtkComboBox` or `GtkEntryCompletion`.
             */
            get hoverSelection(): boolean;
            set hoverSelection(val: boolean);
            /**
             * Extra indentation for each level.
             */
            get level_indentation(): number;
            set level_indentation(val: number);
            /**
             * Extra indentation for each level.
             */
            get levelIndentation(): number;
            set levelIndentation(val: number);
            get model(): TreeModel;
            set model(val: TreeModel);
            get reorderable(): boolean;
            set reorderable(val: boolean);
            get rubber_banding(): boolean;
            set rubber_banding(val: boolean);
            get rubberBanding(): boolean;
            set rubberBanding(val: boolean);
            get search_column(): number;
            set search_column(val: number);
            get searchColumn(): number;
            set searchColumn(val: number);
            /**
             * %TRUE if the view has expanders.
             */
            get show_expanders(): boolean;
            set show_expanders(val: boolean);
            /**
             * %TRUE if the view has expanders.
             */
            get showExpanders(): boolean;
            set showExpanders(val: boolean);
            get tooltip_column(): number;
            set tooltip_column(val: number);
            get tooltipColumn(): number;
            set tooltipColumn(val: number);

            // Constructors

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

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

            static ['new'](): TreeView;

            static new_with_model(model: TreeModel): TreeView;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'columns-changed', callback: (_source: this) => void): number;
            connect_after(signal: 'columns-changed', callback: (_source: this) => void): number;
            emit(signal: 'columns-changed'): void;
            connect(signal: 'cursor-changed', callback: (_source: this) => void): number;
            connect_after(signal: 'cursor-changed', callback: (_source: this) => void): number;
            emit(signal: 'cursor-changed'): void;
            connect(
                signal: 'expand-collapse-cursor-row',
                callback: (_source: this, object: boolean, p0: boolean, p1: boolean) => boolean,
            ): number;
            connect_after(
                signal: 'expand-collapse-cursor-row',
                callback: (_source: this, object: boolean, p0: boolean, p1: boolean) => boolean,
            ): number;
            emit(signal: 'expand-collapse-cursor-row', object: boolean, p0: boolean, p1: boolean): void;
            connect(
                signal: 'move-cursor',
                callback: (
                    _source: this,
                    step: MovementStep,
                    direction: number,
                    extend: boolean,
                    modify: boolean,
                ) => boolean,
            ): number;
            connect_after(
                signal: 'move-cursor',
                callback: (
                    _source: this,
                    step: MovementStep,
                    direction: number,
                    extend: boolean,
                    modify: boolean,
                ) => boolean,
            ): number;
            emit(signal: 'move-cursor', step: MovementStep, direction: number, extend: boolean, modify: boolean): void;
            connect(
                signal: 'row-activated',
                callback: (_source: this, path: TreePath, column: TreeViewColumn | null) => void,
            ): number;
            connect_after(
                signal: 'row-activated',
                callback: (_source: this, path: TreePath, column: TreeViewColumn | null) => void,
            ): number;
            emit(signal: 'row-activated', path: TreePath, column?: TreeViewColumn | null): void;
            connect(signal: 'row-collapsed', callback: (_source: this, iter: TreeIter, path: TreePath) => void): number;
            connect_after(
                signal: 'row-collapsed',
                callback: (_source: this, iter: TreeIter, path: TreePath) => void,
            ): number;
            emit(signal: 'row-collapsed', iter: TreeIter, path: TreePath): void;
            connect(signal: 'row-expanded', callback: (_source: this, iter: TreeIter, path: TreePath) => void): number;
            connect_after(
                signal: 'row-expanded',
                callback: (_source: this, iter: TreeIter, path: TreePath) => void,
            ): number;
            emit(signal: 'row-expanded', iter: TreeIter, path: TreePath): void;
            connect(signal: 'select-all', callback: (_source: this) => boolean): number;
            connect_after(signal: 'select-all', callback: (_source: this) => boolean): number;
            emit(signal: 'select-all'): void;
            connect(signal: 'select-cursor-parent', callback: (_source: this) => boolean): number;
            connect_after(signal: 'select-cursor-parent', callback: (_source: this) => boolean): number;
            emit(signal: 'select-cursor-parent'): void;
            connect(signal: 'select-cursor-row', callback: (_source: this, object: boolean) => boolean): number;
            connect_after(signal: 'select-cursor-row', callback: (_source: this, object: boolean) => boolean): number;
            emit(signal: 'select-cursor-row', object: boolean): void;
            connect(signal: 'start-interactive-search', callback: (_source: this) => boolean): number;
            connect_after(signal: 'start-interactive-search', callback: (_source: this) => boolean): number;
            emit(signal: 'start-interactive-search'): void;
            connect(
                signal: 'test-collapse-row',
                callback: (_source: this, iter: TreeIter, path: TreePath) => boolean,
            ): number;
            connect_after(
                signal: 'test-collapse-row',
                callback: (_source: this, iter: TreeIter, path: TreePath) => boolean,
            ): number;
            emit(signal: 'test-collapse-row', iter: TreeIter, path: TreePath): void;
            connect(
                signal: 'test-expand-row',
                callback: (_source: this, iter: TreeIter, path: TreePath) => boolean,
            ): number;
            connect_after(
                signal: 'test-expand-row',
                callback: (_source: this, iter: TreeIter, path: TreePath) => boolean,
            ): number;
            emit(signal: 'test-expand-row', iter: TreeIter, path: TreePath): void;
            connect(signal: 'toggle-cursor-row', callback: (_source: this) => boolean): number;
            connect_after(signal: 'toggle-cursor-row', callback: (_source: this) => boolean): number;
            emit(signal: 'toggle-cursor-row'): void;
            connect(signal: 'unselect-all', callback: (_source: this) => boolean): number;
            connect_after(signal: 'unselect-all', callback: (_source: this) => boolean): number;
            emit(signal: 'unselect-all'): void;

            // Virtual methods

            vfunc_columns_changed(): void;
            vfunc_cursor_changed(): void;
            vfunc_expand_collapse_cursor_row(logical: boolean, expand: boolean, open_all: boolean): boolean;
            vfunc_move_cursor(step: MovementStep, count: number, extend: boolean, modify: boolean): boolean;
            /**
             * Activates the cell determined by `path` and `column`.
             * @param path The `GtkTreePath` to be activated.
             * @param column The `GtkTreeViewColumn` to be activated.
             */
            vfunc_row_activated(path: TreePath, column?: TreeViewColumn | null): void;
            vfunc_row_collapsed(iter: TreeIter, path: TreePath): void;
            vfunc_row_expanded(iter: TreeIter, path: TreePath): void;
            vfunc_select_all(): boolean;
            vfunc_select_cursor_parent(): boolean;
            vfunc_select_cursor_row(start_editing: boolean): boolean;
            vfunc_start_interactive_search(): boolean;
            vfunc_test_collapse_row(iter: TreeIter, path: TreePath): boolean;
            vfunc_test_expand_row(iter: TreeIter, path: TreePath): boolean;
            vfunc_toggle_cursor_row(): boolean;
            vfunc_unselect_all(): boolean;

            // Methods

            /**
             * Appends `column` to the list of columns. If `tree_view` has “fixed_height”
             * mode enabled, then `column` must have its “sizing” property set to be
             * GTK_TREE_VIEW_COLUMN_FIXED.
             * @param column The `GtkTreeViewColumn` to add.
             * @returns The number of columns in @tree_view after appending.
             */
            append_column(column: TreeViewColumn): number;
            /**
             * Recursively collapses all visible, expanded nodes in `tree_view`.
             */
            collapse_all(): void;
            /**
             * Collapses a row (hides its child rows, if they exist).
             * @param path path to a row in the @tree_view
             * @returns %TRUE if the row was collapsed.
             */
            collapse_row(path: TreePath): boolean;
            /**
             * Resizes all columns to their optimal width. Only works after the
             * treeview has been realized.
             */
            columns_autosize(): void;
            /**
             * Converts bin_window coordinates to coordinates for the
             * tree (the full scrollable area of the tree).
             * @param bx X coordinate relative to bin_window
             * @param by Y coordinate relative to bin_window
             */
            convert_bin_window_to_tree_coords(bx: number, by: number): [number, number];
            /**
             * Converts bin_window coordinates to widget relative coordinates.
             * @param bx bin_window X coordinate
             * @param by bin_window Y coordinate
             */
            convert_bin_window_to_widget_coords(bx: number, by: number): [number, number];
            /**
             * Converts tree coordinates (coordinates in full scrollable area of the tree)
             * to bin_window coordinates.
             * @param tx tree X coordinate
             * @param ty tree Y coordinate
             */
            convert_tree_to_bin_window_coords(tx: number, ty: number): [number, number];
            /**
             * Converts tree coordinates (coordinates in full scrollable area of the tree)
             * to widget coordinates.
             * @param tx X coordinate relative to the tree
             * @param ty Y coordinate relative to the tree
             */
            convert_tree_to_widget_coords(tx: number, ty: number): [number, number];
            /**
             * Converts widget coordinates to coordinates for the bin_window.
             * @param wx X coordinate relative to the widget
             * @param wy Y coordinate relative to the widget
             */
            convert_widget_to_bin_window_coords(wx: number, wy: number): [number, number];
            /**
             * Converts widget coordinates to coordinates for the
             * tree (the full scrollable area of the tree).
             * @param wx X coordinate relative to the widget
             * @param wy Y coordinate relative to the widget
             */
            convert_widget_to_tree_coords(wx: number, wy: number): [number, number];
            /**
             * Creates a `cairo_surface_t` representation of the row at `path`.
             * This image is used for a drag icon.
             * @param path a `GtkTreePath` in @tree_view
             * @returns a newly-allocated surface of the drag icon.
             */
            create_row_drag_icon(path: TreePath): Gdk.Paintable | null;
            /**
             * Turns `tree_view` into a drop destination for automatic DND. Calling
             * this method sets `GtkTreeView`:reorderable to %FALSE.
             * @param formats the target formats that the drag will support
             * @param actions the bitmask of possible actions for a drag from this    widget
             */
            enable_model_drag_dest(formats: Gdk.ContentFormats, actions: Gdk.DragAction | null): void;
            /**
             * Turns `tree_view` into a drag source for automatic DND. Calling this
             * method sets `GtkTreeView`:reorderable to %FALSE.
             * @param start_button_mask Mask of allowed buttons to start drag
             * @param formats the target formats that the drag will support
             * @param actions the bitmask of possible actions for a drag from this    widget
             */
            enable_model_drag_source(
                start_button_mask: Gdk.ModifierType | null,
                formats: Gdk.ContentFormats,
                actions: Gdk.DragAction | null,
            ): void;
            /**
             * Recursively expands all nodes in the `tree_view`.
             */
            expand_all(): void;
            /**
             * Opens the row so its children are visible.
             * @param path path to a row
             * @param open_all whether to recursively expand, or just expand immediate children
             * @returns %TRUE if the row existed and had children
             */
            expand_row(path: TreePath, open_all: boolean): boolean;
            /**
             * Expands the row at `path`. This will also expand all parent rows of
             * `path` as necessary.
             * @param path path to a row.
             */
            expand_to_path(path: TreePath): void;
            /**
             * Gets the setting set by gtk_tree_view_set_activate_on_single_click().
             * @returns %TRUE if row-activated will be emitted on a single click
             */
            get_activate_on_single_click(): boolean;
            /**
             * Fills the bounding rectangle in bin_window coordinates for the cell at the
             * row specified by `path` and the column specified by `column`.  If `path` is
             * %NULL, or points to a node not found in the tree, the `y` and `height` fields of
             * the rectangle will be filled with 0. If `column` is %NULL, the `x` and `width`
             * fields will be filled with 0.  The returned rectangle is equivalent to the
             * `background_area` passed to gtk_cell_renderer_render().  These background
             * areas tile to cover the entire bin window.  Contrast with the `cell_area,`
             * returned by gtk_tree_view_get_cell_area(), which returns only the cell
             * itself, excluding surrounding borders and the tree expander area.
             * @param path a `GtkTreePath` for the row, or %NULL to get only horizontal coordinates
             * @param column a `GtkTreeViewColumn` for the column, or %NULL to get only vertical coordinates
             */
            get_background_area(path: TreePath | null, column: TreeViewColumn | null): Gdk.Rectangle;
            /**
             * Fills the bounding rectangle in bin_window coordinates for the cell at the
             * row specified by `path` and the column specified by `column`.  If `path` is
             * %NULL, or points to a path not currently displayed, the `y` and `height` fields
             * of the rectangle will be filled with 0. If `column` is %NULL, the `x` and `width`
             * fields will be filled with 0.  The sum of all cell rects does not cover the
             * entire tree; there are extra pixels in between rows, for example. The
             * returned rectangle is equivalent to the `cell_area` passed to
             * gtk_cell_renderer_render().  This function is only valid if `tree_view` is
             * realized.
             * @param path a `GtkTreePath` for the row, or %NULL to get only horizontal coordinates
             * @param column a `GtkTreeViewColumn` for the column, or %NULL to get only vertical coordinates
             */
            get_cell_area(path: TreePath | null, column: TreeViewColumn | null): Gdk.Rectangle;
            /**
             * Gets the `GtkTreeViewColumn` at the given position in the #tree_view.
             * @param n The position of the column, counting from 0.
             * @returns The `GtkTreeViewColumn`, or %NULL if the position is outside the range of columns.
             */
            get_column(n: number): TreeViewColumn | null;
            /**
             * Returns a `GList` of all the `GtkTreeViewColumn`s currently in `tree_view`.
             * The returned list must be freed with g_list_free ().
             * @returns A list of `GtkTreeViewColumn`s
             */
            get_columns(): TreeViewColumn[];
            /**
             * Fills in `path` and `focus_column` with the current path and focus column.  If
             * the cursor isn’t currently set, then *`path` will be %NULL.  If no column
             * currently has focus, then *`focus_column` will be %NULL.
             *
             * The returned `GtkTreePath` must be freed with gtk_tree_path_free() when
             * you are done with it.
             */
            get_cursor(): [TreePath | null, TreeViewColumn | null];
            // Conflicted with Gtk.Widget.get_cursor
            get_cursor(...args: never[]): any;
            /**
             * Determines the destination row for a given position.  `drag_x` and
             * `drag_y` are expected to be in widget coordinates.  This function is only
             * meaningful if `tree_view` is realized.  Therefore this function will always
             * return %FALSE if `tree_view` is not realized or does not have a model.
             * @param drag_x the position to determine the destination row for
             * @param drag_y the position to determine the destination row for
             * @returns whether there is a row at the given position, %TRUE if this is indeed the case.
             */
            get_dest_row_at_pos(
                drag_x: number,
                drag_y: number,
            ): [boolean, TreePath | null, TreeViewDropPosition | null];
            /**
             * Gets information about the row that is highlighted for feedback.
             */
            get_drag_dest_row(): [TreePath | null, TreeViewDropPosition | null];
            /**
             * Returns whether or not the tree allows to start interactive searching
             * by typing in text.
             * @returns whether or not to let the user search interactively
             */
            get_enable_search(): boolean;
            /**
             * Returns whether or not tree lines are drawn in `tree_view`.
             * @returns %TRUE if tree lines are drawn in @tree_view, %FALSE otherwise.
             */
            get_enable_tree_lines(): boolean;
            /**
             * Returns the column that is the current expander column,
             * or %NULL if none has been set.
             * This column has the expander arrow drawn next to it.
             * @returns The expander column.
             */
            get_expander_column(): TreeViewColumn | null;
            /**
             * Returns whether fixed height mode is turned on for `tree_view`.
             * @returns %TRUE if @tree_view is in fixed height mode
             */
            get_fixed_height_mode(): boolean;
            /**
             * Returns which grid lines are enabled in `tree_view`.
             * @returns a `GtkTreeView`GridLines value indicating which grid lines are enabled.
             */
            get_grid_lines(): TreeViewGridLines;
            /**
             * Returns whether all header columns are clickable.
             * @returns %TRUE if all header columns are clickable, otherwise %FALSE
             */
            get_headers_clickable(): boolean;
            /**
             * Returns %TRUE if the headers on the `tree_view` are visible.
             * @returns Whether the headers are visible or not.
             */
            get_headers_visible(): boolean;
            /**
             * Returns whether hover expansion mode is turned on for `tree_view`.
             * @returns %TRUE if @tree_view is in hover expansion mode
             */
            get_hover_expand(): boolean;
            /**
             * Returns whether hover selection mode is turned on for `tree_view`.
             * @returns %TRUE if @tree_view is in hover selection mode
             */
            get_hover_selection(): boolean;
            /**
             * Returns the amount, in pixels, of extra indentation for child levels
             * in `tree_view`.
             * @returns the amount of extra indentation for child levels in @tree_view.  A return value of 0 means that this feature is disabled.
             */
            get_level_indentation(): number;
            /**
             * Returns the model the `GtkTreeView` is based on.  Returns %NULL if the
             * model is unset.
             * @returns A `GtkTreeModel`
             */
            get_model(): TreeModel | null;
            /**
             * Queries the number of columns in the given `tree_view`.
             * @returns The number of columns in the @tree_view
             */
            get_n_columns(): number;
            /**
             * Finds the path at the point (`x,` `y)`, relative to bin_window coordinates.
             * That is, `x` and `y` are relative to an events coordinates. Widget-relative
             * coordinates must be converted using
             * gtk_tree_view_convert_widget_to_bin_window_coords(). It is primarily for
             * things like popup menus. If `path` is non-%NULL, then it will be filled
             * with the `GtkTreePath` at that point.  This path should be freed with
             * gtk_tree_path_free().  If `column` is non-%NULL, then it will be filled
             * with the column at that point.  `cell_x` and `cell_y` return the coordinates
             * relative to the cell background (i.e. the `background_area` passed to
             * gtk_cell_renderer_render()).  This function is only meaningful if
             * `tree_view` is realized.  Therefore this function will always return %FALSE
             * if `tree_view` is not realized or does not have a model.
             *
             * For converting widget coordinates (eg. the ones you get from
             * GtkWidget::query-tooltip), please see
             * gtk_tree_view_convert_widget_to_bin_window_coords().
             * @param x The x position to be identified (relative to bin_window).
             * @param y The y position to be identified (relative to bin_window).
             * @returns %TRUE if a row exists at that coordinate.
             */
            get_path_at_pos(x: number, y: number): [boolean, TreePath | null, TreeViewColumn | null, number, number];
            /**
             * Retrieves whether the user can reorder the tree via drag-and-drop. See
             * gtk_tree_view_set_reorderable().
             * @returns %TRUE if the tree can be reordered.
             */
            get_reorderable(): boolean;
            /**
             * Returns whether rubber banding is turned on for `tree_view`.  If the
             * selection mode is %GTK_SELECTION_MULTIPLE, rubber banding will allow the
             * user to select multiple rows by dragging the mouse.
             * @returns %TRUE if rubber banding in @tree_view is enabled.
             */
            get_rubber_banding(): boolean;
            /**
             * Gets the column searched on by the interactive search code.
             * @returns the column the interactive search code searches in.
             */
            get_search_column(): number;
            /**
             * Returns the `GtkEntry` which is currently in use as interactive search
             * entry for `tree_view`.  In case the built-in entry is being used, %NULL
             * will be returned.
             * @returns the entry currently in use as search entry.
             */
            get_search_entry(): Editable | null;
            /**
             * Gets the `GtkTreeSelection` associated with `tree_view`.
             * @returns A `GtkTreeSelection` object.
             */
            get_selection(): TreeSelection;
            /**
             * Returns whether or not expanders are drawn in `tree_view`.
             * @returns %TRUE if expanders are drawn in @tree_view, %FALSE otherwise.
             */
            get_show_expanders(): boolean;
            /**
             * Returns the column of `tree_view’`s model which is being used for
             * displaying tooltips on `tree_view’`s rows.
             * @returns the index of the tooltip column that is currently being used, or -1 if this is disabled.
             */
            get_tooltip_column(): number;
            /**
             * This function is supposed to be used in a ::query-tooltip
             * signal handler for `GtkTreeView`. The `x,` `y` and `keyboard_tip` values
             * which are received in the signal handler, should be passed to this
             * function without modification.
             *
             * The return value indicates whether there is a tree view row at the given
             * coordinates (%TRUE) or not (%FALSE) for mouse tooltips. For keyboard
             * tooltips the row returned will be the cursor row. When %TRUE, then any of
             * `model,` `path` and `iter` which have been provided will be set to point to
             * that row and the corresponding model. `x` and `y` will always be converted
             * to be relative to `tree_view’`s bin_window if `keyboard_tooltip` is %FALSE.
             * @param x the x coordinate (relative to widget coordinates)
             * @param y the y coordinate (relative to widget coordinates)
             * @param keyboard_tip whether this is a keyboard tooltip or not
             * @returns whether or not the given tooltip context points to a row
             */
            get_tooltip_context(
                x: number,
                y: number,
                keyboard_tip: boolean,
            ): [boolean, TreeModel | null, TreePath | null, TreeIter | null];
            /**
             * Sets `start_path` and `end_path` to be the first and last visible path.
             * Note that there may be invisible paths in between.
             *
             * The paths should be freed with gtk_tree_path_free() after use.
             * @returns %TRUE, if valid paths were placed in @start_path and @end_path.
             */
            get_visible_range(): [boolean, TreePath | null, TreePath | null];
            /**
             * Fills `visible_rect` with the currently-visible region of the
             * buffer, in tree coordinates. Convert to bin_window coordinates with
             * gtk_tree_view_convert_tree_to_bin_window_coords().
             * Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
             * scrollable area of the tree.
             */
            get_visible_rect(): Gdk.Rectangle;
            /**
             * This inserts the `column` into the `tree_view` at `position`.  If `position` is
             * -1, then the column is inserted at the end. If `tree_view` has
             * “fixed_height” mode enabled, then `column` must have its “sizing” property
             * set to be GTK_TREE_VIEW_COLUMN_FIXED.
             * @param column The `GtkTreeViewColumn` to be inserted.
             * @param position The position to insert @column in.
             * @returns The number of columns in @tree_view after insertion.
             */
            insert_column(column: TreeViewColumn, position: number): number;
            /**
             * Convenience function that inserts a new column into the `GtkTreeView`
             * with the given cell renderer and a `GtkTreeCellDataFunc` to set cell renderer
             * attributes (normally using data from the model). See also
             * gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
             * If `tree_view` has “fixed_height” mode enabled, then the new column will have its
             * “sizing” property set to be GTK_TREE_VIEW_COLUMN_FIXED.
             * @param position Position to insert, -1 for append
             * @param title column title
             * @param cell cell renderer for column
             * @param func function to set attributes of cell renderer
             * @returns number of columns in the tree view post-insert
             */
            insert_column_with_data_func(
                position: number,
                title: string,
                cell: CellRenderer,
                func: TreeCellDataFunc,
            ): number;
            /**
             * Determine whether the point (`x,` `y)` in `tree_view` is blank, that is no
             * cell content nor an expander arrow is drawn at the location. If so, the
             * location can be considered as the background. You might wish to take
             * special action on clicks on the background, such as clearing a current
             * selection, having a custom context menu or starting rubber banding.
             *
             * The `x` and `y` coordinate that are provided must be relative to bin_window
             * coordinates.  Widget-relative coordinates must be converted using
             * gtk_tree_view_convert_widget_to_bin_window_coords().
             *
             * For converting widget coordinates (eg. the ones you get from
             * GtkWidget::query-tooltip), please see
             * gtk_tree_view_convert_widget_to_bin_window_coords().
             *
             * The `path,` `column,` `cell_x` and `cell_y` arguments will be filled in
             * likewise as for gtk_tree_view_get_path_at_pos().  Please see
             * gtk_tree_view_get_path_at_pos() for more information.
             * @param x The x position to be identified (relative to bin_window)
             * @param y The y position to be identified (relative to bin_window)
             * @returns %TRUE if the area at the given coordinates is blank, %FALSE otherwise.
             */
            is_blank_at_pos(x: number, y: number): [boolean, TreePath | null, TreeViewColumn | null, number, number];
            /**
             * Returns whether a rubber banding operation is currently being done
             * in `tree_view`.
             * @returns %TRUE if a rubber banding operation is currently being done in @tree_view.
             */
            is_rubber_banding_active(): boolean;
            /**
             * Calls `func` on all expanded rows.
             * @param func A function to be called
             */
            map_expanded_rows(func: TreeViewMappingFunc): void;
            /**
             * Moves `column` to be after to `base_column`.  If `base_column` is %NULL, then
             * `column` is placed in the first position.
             * @param column The `GtkTreeViewColumn` to be moved.
             * @param base_column The `GtkTreeViewColumn` to be moved relative to
             */
            move_column_after(column: TreeViewColumn, base_column?: TreeViewColumn | null): void;
            /**
             * Removes `column` from `tree_view`.
             * @param column The `GtkTreeViewColumn` to remove.
             * @returns The number of columns in @tree_view after removing.
             */
            remove_column(column: TreeViewColumn): number;
            /**
             * Activates the cell determined by `path` and `column`.
             * @param path The `GtkTreePath` to be activated.
             * @param column The `GtkTreeViewColumn` to be activated.
             */
            row_activated(path: TreePath, column?: TreeViewColumn | null): void;
            /**
             * Returns %TRUE if the node pointed to by `path` is expanded in `tree_view`.
             * @param path A `GtkTreePath` to test expansion state.
             * @returns %TRUE if #path is expanded.
             */
            row_expanded(path: TreePath): boolean;
            /**
             * Moves the alignments of `tree_view` to the position specified by `column` and
             * `path`.  If `column` is %NULL, then no horizontal scrolling occurs.  Likewise,
             * if `path` is %NULL no vertical scrolling occurs.  At a minimum, one of `column`
             * or `path` need to be non-%NULL.  `row_align` determines where the row is
             * placed, and `col_align` determines where `column` is placed.  Both are expected
             * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
             * right/bottom alignment, 0.5 means center.
             *
             * If `use_align` is %FALSE, then the alignment arguments are ignored, and the
             * tree does the minimum amount of work to scroll the cell onto the screen.
             * This means that the cell will be scrolled to the edge closest to its current
             * position.  If the cell is currently visible on the screen, nothing is done.
             *
             * This function only works if the model is set, and `path` is a valid row on the
             * model.  If the model changes before the `tree_view` is realized, the centered
             * path will be modified to reflect this change.
             * @param path The path of the row to move to
             * @param column The `GtkTreeViewColumn` to move horizontally to
             * @param use_align whether to use alignment arguments, or %FALSE.
             * @param row_align The vertical alignment of the row specified by @path.
             * @param col_align The horizontal alignment of the column specified by @column.
             */
            scroll_to_cell(
                path: TreePath | null,
                column: TreeViewColumn | null,
                use_align: boolean,
                row_align: number,
                col_align: number,
            ): void;
            /**
             * Scrolls the tree view such that the top-left corner of the visible
             * area is `tree_x,` `tree_y,` where `tree_x` and `tree_y` are specified
             * in tree coordinates.  The `tree_view` must be realized before
             * this function is called.  If it isn't, you probably want to be
             * using gtk_tree_view_scroll_to_cell().
             *
             * If either `tree_x` or `tree_y` are -1, then that direction isn’t scrolled.
             * @param tree_x X coordinate of new top-left pixel of visible area, or -1
             * @param tree_y Y coordinate of new top-left pixel of visible area, or -1
             */
            scroll_to_point(tree_x: number, tree_y: number): void;
            /**
             * Cause the `GtkTreeView`::row-activated signal to be emitted
             * on a single click instead of a double click.
             * @param single %TRUE to emit row-activated on a single click
             */
            set_activate_on_single_click(single: boolean): void;
            /**
             * Sets a user function for determining where a column may be dropped when
             * dragged.  This function is called on every column pair in turn at the
             * beginning of a column drag to determine where a drop can take place.  The
             * arguments passed to `func` are: the `tree_view,` the `GtkTreeViewColumn` being
             * dragged, the two `GtkTreeViewColumn`s determining the drop spot, and
             * `user_data`.  If either of the `GtkTreeViewColumn` arguments for the drop spot
             * are %NULL, then they indicate an edge.  If `func` is set to be %NULL, then
             * `tree_view` reverts to the default behavior of allowing all columns to be
             * dropped everywhere.
             * @param func A function to determine which columns are reorderable
             * @param destroy Destroy notifier for @user_data
             */
            set_column_drag_function(func?: TreeViewColumnDropFunc | null, destroy?: GLib.DestroyNotify | null): void;
            /**
             * Sets the current keyboard focus to be at `path,` and selects it.  This is
             * useful when you want to focus the user’s attention on a particular row.  If
             * `focus_column` is not %NULL, then focus is given to the column specified by
             * it. Additionally, if `focus_column` is specified, and `start_editing` is
             * %TRUE, then editing should be started in the specified cell.
             * This function is often followed by `gtk_widget_grab_focus` (`tree_view)`
             * in order to give keyboard focus to the widget.  Please note that editing
             * can only happen when the widget is realized.
             *
             * If `path` is invalid for `model,` the current cursor (if any) will be unset
             * and the function will return without failing.
             * @param path A `GtkTreePath`
             * @param focus_column A `GtkTreeViewColumn`
             * @param start_editing %TRUE if the specified cell should start being edited.
             */
            set_cursor(path: TreePath, focus_column: TreeViewColumn | null, start_editing: boolean): void;
            // Conflicted with Gtk.Widget.set_cursor
            set_cursor(...args: never[]): any;
            /**
             * Sets the current keyboard focus to be at `path,` and selects it.  This is
             * useful when you want to focus the user’s attention on a particular row.  If
             * `focus_column` is not %NULL, then focus is given to the column specified by
             * it. If `focus_column` and `focus_cell` are not %NULL, and `focus_column`
             * contains 2 or more editable or activatable cells, then focus is given to
             * the cell specified by `focus_cell`. Additionally, if `focus_column` is
             * specified, and `start_editing` is %TRUE, then editing should be started in
             * the specified cell.  This function is often followed by
             * `gtk_widget_grab_focus` (`tree_view)` in order to give keyboard focus to the
             * widget.  Please note that editing can only happen when the widget is
             * realized.
             *
             * If `path` is invalid for `model,` the current cursor (if any) will be unset
             * and the function will return without failing.
             * @param path A `GtkTreePath`
             * @param focus_column A `GtkTreeViewColumn`
             * @param focus_cell A `GtkCellRenderer`
             * @param start_editing %TRUE if the specified cell should start being edited.
             */
            set_cursor_on_cell(
                path: TreePath,
                focus_column: TreeViewColumn | null,
                focus_cell: CellRenderer | null,
                start_editing: boolean,
            ): void;
            /**
             * Sets the row that is highlighted for feedback.
             * If `path` is %NULL, an existing highlight is removed.
             * @param path The path of the row to highlight
             * @param pos Specifies whether to drop before, after or into the row
             */
            set_drag_dest_row(path: TreePath | null, pos: TreeViewDropPosition | null): void;
            /**
             * If `enable_search` is set, then the user can type in text to search through
             * the tree interactively (this is sometimes called "typeahead find").
             *
             * Note that even if this is %FALSE, the user can still initiate a search
             * using the “start-interactive-search” key binding.
             * @param enable_search %TRUE, if the user can search interactively
             */
            set_enable_search(enable_search: boolean): void;
            /**
             * Sets whether to draw lines interconnecting the expanders in `tree_view`.
             * This does not have any visible effects for lists.
             * @param enabled %TRUE to enable tree line drawing, %FALSE otherwise.
             */
            set_enable_tree_lines(enabled: boolean): void;
            /**
             * Sets the column to draw the expander arrow at. It must be in `tree_view`.
             * If `column` is %NULL, then the expander arrow is always at the first
             * visible column.
             *
             * If you do not want expander arrow to appear in your tree, set the
             * expander column to a hidden column.
             * @param column %NULL, or the column to draw the expander arrow at.
             */
            set_expander_column(column?: TreeViewColumn | null): void;
            /**
             * Enables or disables the fixed height mode of `tree_view`.
             * Fixed height mode speeds up `GtkTreeView` by assuming that all
             * rows have the same height.
             * Only enable this option if all rows are the same height and all
             * columns are of type %GTK_TREE_VIEW_COLUMN_FIXED.
             * @param enable %TRUE to enable fixed height mode
             */
            set_fixed_height_mode(enable: boolean): void;
            /**
             * Sets which grid lines to draw in `tree_view`.
             * @param grid_lines a `GtkTreeView`GridLines value indicating which grid lines to enable.
             */
            set_grid_lines(grid_lines: TreeViewGridLines | null): void;
            /**
             * Allow the column title buttons to be clicked.
             * @param setting %TRUE if the columns are clickable.
             */
            set_headers_clickable(setting: boolean): void;
            /**
             * Sets the visibility state of the headers.
             * @param headers_visible %TRUE if the headers are visible
             */
            set_headers_visible(headers_visible: boolean): void;
            /**
             * Enables or disables the hover expansion mode of `tree_view`.
             * Hover expansion makes rows expand or collapse if the pointer
             * moves over them.
             * @param expand %TRUE to enable hover selection mode
             */
            set_hover_expand(expand: boolean): void;
            /**
             * Enables or disables the hover selection mode of `tree_view`.
             * Hover selection makes the selected row follow the pointer.
             * Currently, this works only for the selection modes
             * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
             * @param hover %TRUE to enable hover selection mode
             */
            set_hover_selection(hover: boolean): void;
            /**
             * Sets the amount of extra indentation for child levels to use in `tree_view`
             * in addition to the default indentation.  The value should be specified in
             * pixels, a value of 0 disables this feature and in this case only the default
             * indentation will be used.
             * This does not have any visible effects for lists.
             * @param indentation the amount, in pixels, of extra indentation in @tree_view.
             */
            set_level_indentation(indentation: number): void;
            /**
             * Sets the model for a `GtkTreeView`.  If the `tree_view` already has a model
             * set, it will remove it before setting the new model.  If `model` is %NULL,
             * then it will unset the old model.
             * @param model The model.
             */
            set_model(model?: TreeModel | null): void;
            /**
             * This function is a convenience function to allow you to reorder
             * models that support the `GtkTreeDragSourceIface` and the
             * `GtkTreeDragDestIface`.  Both `GtkTreeStore` and `GtkListStore` support
             * these.  If `reorderable` is %TRUE, then the user can reorder the
             * model by dragging and dropping rows. The developer can listen to
             * these changes by connecting to the model’s `GtkTreeModel::row-inserted`
             * and `GtkTreeModel::row-deleted` signals. The reordering is implemented
             * by setting up the tree view as a drag source and destination.
             * Therefore, drag and drop can not be used in a reorderable view for any
             * other purpose.
             *
             * This function does not give you any degree of control over the order -- any
             * reordering is allowed.  If more control is needed, you should probably
             * handle drag and drop manually.
             * @param reorderable %TRUE, if the tree can be reordered.
             */
            set_reorderable(reorderable: boolean): void;
            /**
             * Sets the row separator function, which is used to determine
             * whether a row should be drawn as a separator. If the row separator
             * function is %NULL, no separators are drawn. This is the default value.
             * @param func a `GtkTreeView`RowSeparatorFunc
             * @param destroy destroy notifier for @data
             */
            set_row_separator_func(func?: TreeViewRowSeparatorFunc | null, destroy?: GLib.DestroyNotify | null): void;
            /**
             * Enables or disables rubber banding in `tree_view`.  If the selection mode
             * is %GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
             * multiple rows by dragging the mouse.
             * @param enable %TRUE to enable rubber banding
             */
            set_rubber_banding(enable: boolean): void;
            /**
             * Sets `column` as the column where the interactive search code should
             * search in for the current model.
             *
             * If the search column is set, users can use the “start-interactive-search”
             * key binding to bring up search popup. The enable-search property controls
             * whether simply typing text will also start an interactive search.
             *
             * Note that `column` refers to a column of the current model. The search
             * column is reset to -1 when the model is changed.
             * @param column the column of the model to search in, or -1 to disable searching
             */
            set_search_column(column: number): void;
            /**
             * Sets the entry which the interactive search code will use for this
             * `tree_view`.  This is useful when you want to provide a search entry
             * in our interface at all time at a fixed position.  Passing %NULL for
             * `entry` will make the interactive search code use the built-in popup
             * entry again.
             * @param entry the entry the interactive search code of @tree_view should use
             */
            set_search_entry(entry?: Editable | null): void;
            /**
             * Sets the compare function for the interactive search capabilities; note
             * that somewhat like strcmp() returning 0 for equality
             * `GtkTreeView`SearchEqualFunc returns %FALSE on matches.
             * @param search_equal_func the compare function to use during the search
             * @param search_destroy Destroy notifier for @search_user_data
             */
            set_search_equal_func(
                search_equal_func: TreeViewSearchEqualFunc,
                search_destroy?: GLib.DestroyNotify | null,
            ): void;
            /**
             * Sets whether to draw and enable expanders and indent child rows in
             * `tree_view`.  When disabled there will be no expanders visible in trees
             * and there will be no way to expand and collapse rows by default.  Also
             * note that hiding the expanders will disable the default indentation.  You
             * can set a custom indentation in this case using
             * gtk_tree_view_set_level_indentation().
             * This does not have any visible effects for lists.
             * @param enabled %TRUE to enable expander drawing, %FALSE otherwise.
             */
            set_show_expanders(enabled: boolean): void;
            /**
             * Sets the tip area of `tooltip` to the area `path,` `column` and `cell` have
             * in common.  For example if `path` is %NULL and `column` is set, the tip
             * area will be set to the full area covered by `column`.  See also
             * gtk_tooltip_set_tip_area().
             *
             * Note that if `path` is not specified and `cell` is set and part of a column
             * containing the expander, the tooltip might not show and hide at the correct
             * position.  In such cases `path` must be set to the current node under the
             * mouse cursor for this function to operate correctly.
             *
             * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
             * @param tooltip a `GtkTooltip`
             * @param path a `GtkTreePath`
             * @param column a `GtkTreeViewColumn`
             * @param cell a `GtkCellRenderer`
             */
            set_tooltip_cell(
                tooltip: Tooltip,
                path?: TreePath | null,
                column?: TreeViewColumn | null,
                cell?: CellRenderer | null,
            ): void;
            /**
             * If you only plan to have simple (text-only) tooltips on full rows, you
             * can use this function to have `GtkTreeView` handle these automatically
             * for you. `column` should be set to the column in `tree_view’`s model
             * containing the tooltip texts, or -1 to disable this feature.
             *
             * When enabled, `GtkWidget:has-tooltip` will be set to %TRUE and
             * `tree_view` will connect a `GtkWidget::query-tooltip` signal handler.
             *
             * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
             * so &, <, etc have to be escaped in the text.
             * @param column an integer, which is a valid column number for @tree_view’s model
             */
            set_tooltip_column(column: number): void;
            /**
             * Sets the tip area of `tooltip` to be the area covered by the row at `path`.
             * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
             * See also gtk_tooltip_set_tip_area().
             * @param tooltip a `GtkTooltip`
             * @param path a `GtkTreePath`
             */
            set_tooltip_row(tooltip: Tooltip, path: TreePath): void;
            /**
             * Undoes the effect of
             * gtk_tree_view_enable_model_drag_dest(). Calling this method sets
             * `GtkTreeView`:reorderable to %FALSE.
             */
            unset_rows_drag_dest(): void;
            /**
             * Undoes the effect of
             * gtk_tree_view_enable_model_drag_source(). Calling this method sets
             * `GtkTreeView`:reorderable to %FALSE.
             */
            unset_rows_drag_source(): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * Horizontal `GtkAdjustment` of the scrollable widget.
             *
             * This adjustment is shared between the scrollable widget and its parent.
             */
            get hadjustment(): Adjustment;
            set hadjustment(val: Adjustment);
            /**
             * Determines when horizontal scrolling should start.
             */
            get hscroll_policy(): ScrollablePolicy;
            set hscroll_policy(val: ScrollablePolicy);
            /**
             * Determines when horizontal scrolling should start.
             */
            get hscrollPolicy(): ScrollablePolicy;
            set hscrollPolicy(val: ScrollablePolicy);
            /**
             * Vertical `GtkAdjustment` of the scrollable widget.
             *
             * This adjustment is shared between the scrollable widget and its parent.
             */
            get vadjustment(): Adjustment;
            set vadjustment(val: Adjustment);
            /**
             * Determines when vertical scrolling should start.
             */
            get vscroll_policy(): ScrollablePolicy;
            set vscroll_policy(val: ScrollablePolicy);
            /**
             * Determines when vertical scrolling should start.
             */
            get vscrollPolicy(): ScrollablePolicy;
            set vscrollPolicy(val: ScrollablePolicy);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Returns the size of a non-scrolling border around the
             * outside of the scrollable.
             *
             * An example for this would be treeview headers. GTK can use
             * this information to display overlaid graphics, like the
             * overshoot indication, at the right position.
             * @returns %TRUE if @border has been set
             */
            get_border(): [boolean, Border];
            /**
             * Retrieves the `GtkAdjustment` used for horizontal scrolling.
             * @returns horizontal `GtkAdjustment`.
             */
            get_hadjustment(): Adjustment | null;
            /**
             * Gets the horizontal `GtkScrollablePolicy`.
             * @returns The horizontal `GtkScrollablePolicy`.
             */
            get_hscroll_policy(): ScrollablePolicy;
            /**
             * Retrieves the `GtkAdjustment` used for vertical scrolling.
             * @returns vertical `GtkAdjustment`.
             */
            get_vadjustment(): Adjustment | null;
            /**
             * Gets the vertical `GtkScrollablePolicy`.
             * @returns The vertical `GtkScrollablePolicy`.
             */
            get_vscroll_policy(): ScrollablePolicy;
            /**
             * Sets the horizontal adjustment of the `GtkScrollable`.
             * @param hadjustment a `GtkAdjustment`
             */
            set_hadjustment(hadjustment?: Adjustment | null): void;
            /**
             * Sets the `GtkScrollablePolicy`.
             *
             * The policy determines whether horizontal scrolling should start
             * below the minimum width or below the natural width.
             * @param policy the horizontal `GtkScrollablePolicy`
             */
            set_hscroll_policy(policy: ScrollablePolicy | null): void;
            /**
             * Sets the vertical adjustment of the `GtkScrollable`.
             * @param vadjustment a `GtkAdjustment`
             */
            set_vadjustment(vadjustment?: Adjustment | null): void;
            /**
             * Sets the `GtkScrollablePolicy`.
             *
             * The policy determines whether vertical scrolling should start
             * below the minimum height or below the natural height.
             * @param policy the vertical `GtkScrollablePolicy`
             */
            set_vscroll_policy(policy: ScrollablePolicy | null): void;
            /**
             * Returns the size of a non-scrolling border around the
             * outside of the scrollable.
             *
             * An example for this would be treeview headers. GTK can use
             * this information to display overlaid graphics, like the
             * overshoot indication, at the right position.
             */
            vfunc_get_border(): [boolean, Border];
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace TreeViewColumn {
            // Signal callback interfaces

            interface Clicked {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends GObject.InitiallyUnowned.ConstructorProps,
                    Buildable.ConstructorProps,
                    CellLayout.ConstructorProps {
                alignment: number;
                cell_area: CellArea;
                cellArea: CellArea;
                clickable: boolean;
                expand: boolean;
                fixed_width: number;
                fixedWidth: number;
                max_width: number;
                maxWidth: number;
                min_width: number;
                minWidth: number;
                reorderable: boolean;
                resizable: boolean;
                sizing: TreeViewColumnSizing;
                sort_column_id: number;
                sortColumnId: number;
                sort_indicator: boolean;
                sortIndicator: boolean;
                sort_order: SortType;
                sortOrder: SortType;
                spacing: number;
                title: string;
                visible: boolean;
                widget: Widget;
                width: number;
                x_offset: number;
                xOffset: number;
            }
        }

        /**
         * A visible column in a [class`Gtk`.TreeView] widget
         *
         * The `GtkTreeViewColumn` object represents a visible column in a `GtkTreeView` widget.
         * It allows to set properties of the column header, and functions as a holding pen
         * for the cell renderers which determine how the data in the column is displayed.
         *
         * Please refer to the [tree widget conceptual overview](section-tree-widget.html)
         * for an overview of all the objects and data types related to the tree widget and
         * how they work together, and to the [class`Gtk`.TreeView] documentation for specifics
         * about the CSS node structure for treeviews and their headers.
         */
        class TreeViewColumn extends GObject.InitiallyUnowned implements Buildable, CellLayout {
            static $gtype: GObject.GType<TreeViewColumn>;

            // Properties

            get alignment(): number;
            set alignment(val: number);
            /**
             * The `GtkCellArea` used to layout cell renderers for this column.
             *
             * If no area is specified when creating the tree view column with gtk_tree_view_column_new_with_area()
             * a horizontally oriented `GtkCellAreaBox` will be used.
             */
            get cell_area(): CellArea;
            /**
             * The `GtkCellArea` used to layout cell renderers for this column.
             *
             * If no area is specified when creating the tree view column with gtk_tree_view_column_new_with_area()
             * a horizontally oriented `GtkCellAreaBox` will be used.
             */
            get cellArea(): CellArea;
            get clickable(): boolean;
            set clickable(val: boolean);
            get expand(): boolean;
            set expand(val: boolean);
            get fixed_width(): number;
            set fixed_width(val: number);
            get fixedWidth(): number;
            set fixedWidth(val: number);
            get max_width(): number;
            set max_width(val: number);
            get maxWidth(): number;
            set maxWidth(val: number);
            get min_width(): number;
            set min_width(val: number);
            get minWidth(): number;
            set minWidth(val: number);
            get reorderable(): boolean;
            set reorderable(val: boolean);
            get resizable(): boolean;
            set resizable(val: boolean);
            get sizing(): TreeViewColumnSizing;
            set sizing(val: TreeViewColumnSizing);
            /**
             * Logical sort column ID this column sorts on when selected for sorting. Setting the sort column ID makes the column header
             * clickable. Set to -1 to make the column unsortable.
             */
            get sort_column_id(): number;
            set sort_column_id(val: number);
            /**
             * Logical sort column ID this column sorts on when selected for sorting. Setting the sort column ID makes the column header
             * clickable. Set to -1 to make the column unsortable.
             */
            get sortColumnId(): number;
            set sortColumnId(val: number);
            get sort_indicator(): boolean;
            set sort_indicator(val: boolean);
            get sortIndicator(): boolean;
            set sortIndicator(val: boolean);
            get sort_order(): SortType;
            set sort_order(val: SortType);
            get sortOrder(): SortType;
            set sortOrder(val: SortType);
            get spacing(): number;
            set spacing(val: number);
            get title(): string;
            set title(val: string);
            get visible(): boolean;
            set visible(val: boolean);
            get widget(): Widget;
            set widget(val: Widget);
            get width(): number;
            get x_offset(): number;
            get xOffset(): number;

            // Constructors

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

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

            static ['new'](): TreeViewColumn;

            static new_with_area(area: CellArea): TreeViewColumn;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'clicked', callback: (_source: this) => void): number;
            connect_after(signal: 'clicked', callback: (_source: this) => void): number;
            emit(signal: 'clicked'): void;

            // Methods

            /**
             * Adds an attribute mapping to the list in `tree_column`.
             *
             * The `column` is the
             * column of the model to get a value from, and the `attribute` is the
             * parameter on `cell_renderer` to be set from the value. So for example
             * if column 2 of the model contains strings, you could have the
             * “text” attribute of a `GtkCellRendererText` get its values from
             * column 2.
             * @param cell_renderer the `GtkCellRenderer` to set attributes on
             * @param attribute An attribute on the renderer
             * @param column The column position on the model to get the attribute from.
             */
            add_attribute(cell_renderer: CellRenderer, attribute: string, column: number): void;
            /**
             * Obtains the horizontal position and size of a cell in a column.
             *
             * If the  cell is not found in the column, `start_pos` and `width`
             * are not changed and %FALSE is returned.
             * @param cell_renderer a `GtkCellRenderer`
             * @returns %TRUE if @cell belongs to @tree_column
             */
            cell_get_position(cell_renderer: CellRenderer): [boolean, number, number];
            /**
             * Obtains the width and height needed to render the column.  This is used
             * primarily by the `GtkTreeView`.
             */
            cell_get_size(): [number, number, number, number];
            /**
             * Returns %TRUE if any of the cells packed into the `tree_column` are visible.
             * For this to be meaningful, you must first initialize the cells with
             * gtk_tree_view_column_cell_set_cell_data()
             * @returns %TRUE, if any of the cells packed into the @tree_column are currently visible
             */
            cell_is_visible(): boolean;
            /**
             * Sets the cell renderer based on the `tree_model` and `iter`.  That is, for
             * every attribute mapping in `tree_column,` it will get a value from the set
             * column on the `iter,` and use that value to set the attribute on the cell
             * renderer.  This is used primarily by the `GtkTreeView`.
             * @param tree_model The `GtkTreeModel` to get the cell renderers attributes from.
             * @param iter The `GtkTreeIter` to get the cell renderer’s attributes from.
             * @param is_expander %TRUE, if the row has children
             * @param is_expanded %TRUE, if the row has visible children
             */
            cell_set_cell_data(tree_model: TreeModel, iter: TreeIter, is_expander: boolean, is_expanded: boolean): void;
            /**
             * Unsets all the mappings on all renderers on the `tree_column`.
             */
            clear(): void;
            /**
             * Clears all existing attributes previously set with
             * gtk_tree_view_column_set_attributes().
             * @param cell_renderer a `GtkCellRenderer` to clear the attribute mapping on.
             */
            clear_attributes(cell_renderer: CellRenderer): void;
            /**
             * Emits the “clicked” signal on the column.  This function will only work if
             * `tree_column` is clickable.
             */
            clicked(): void;
            /**
             * Sets the current keyboard focus to be at `cell,` if the column contains
             * 2 or more editable and activatable cells.
             * @param cell A `GtkCellRenderer`
             */
            focus_cell(cell: CellRenderer): void;
            /**
             * Returns the current x alignment of `tree_column`.  This value can range
             * between 0.0 and 1.0.
             * @returns The current alignent of @tree_column.
             */
            get_alignment(): number;
            /**
             * Returns the button used in the treeview column header
             * @returns The button for the column header.
             */
            get_button(): Widget;
            /**
             * Returns %TRUE if the user can click on the header for the column.
             * @returns %TRUE if user can click the column header.
             */
            get_clickable(): boolean;
            /**
             * Returns %TRUE if the column expands to fill available space.
             * @returns %TRUE if the column expands to fill available space.
             */
            get_expand(): boolean;
            /**
             * Gets the fixed width of the column.  This may not be the actual displayed
             * width of the column; for that, use gtk_tree_view_column_get_width().
             * @returns The fixed width of the column.
             */
            get_fixed_width(): number;
            /**
             * Returns the maximum width in pixels of the `tree_column,` or -1 if no maximum
             * width is set.
             * @returns The maximum width of the @tree_column.
             */
            get_max_width(): number;
            /**
             * Returns the minimum width in pixels of the `tree_column,` or -1 if no minimum
             * width is set.
             * @returns The minimum width of the @tree_column.
             */
            get_min_width(): number;
            /**
             * Returns %TRUE if the `tree_column` can be reordered by the user.
             * @returns %TRUE if the @tree_column can be reordered by the user.
             */
            get_reorderable(): boolean;
            /**
             * Returns %TRUE if the `tree_column` can be resized by the end user.
             * @returns %TRUE, if the @tree_column can be resized.
             */
            get_resizable(): boolean;
            /**
             * Returns the current type of `tree_column`.
             * @returns The type of @tree_column.
             */
            get_sizing(): TreeViewColumnSizing;
            /**
             * Gets the logical `sort_column_id` that the model sorts on
             * when this column is selected for sorting.
             *
             * See [method`Gtk`.TreeViewColumn.set_sort_column_id].
             * @returns the current @sort_column_id for this column, or -1 if   this column can’t be used for sorting
             */
            get_sort_column_id(): number;
            /**
             * Gets the value set by gtk_tree_view_column_set_sort_indicator().
             * @returns whether the sort indicator arrow is displayed
             */
            get_sort_indicator(): boolean;
            /**
             * Gets the value set by gtk_tree_view_column_set_sort_order().
             * @returns the sort order the sort indicator is indicating
             */
            get_sort_order(): SortType;
            /**
             * Returns the spacing of `tree_column`.
             * @returns the spacing of @tree_column.
             */
            get_spacing(): number;
            /**
             * Returns the title of the widget.
             * @returns the title of the column. This string should not be modified or freed.
             */
            get_title(): string;
            /**
             * Returns the `GtkTreeView` wherein `tree_column` has been inserted.
             * If `column` is currently not inserted in any tree view, %NULL is
             * returned.
             * @returns The tree view wherein @column   has been inserted
             */
            get_tree_view(): Widget | null;
            /**
             * Returns %TRUE if `tree_column` is visible.
             * @returns whether the column is visible or not.  If it is visible, then the tree will show the column.
             */
            get_visible(): boolean;
            /**
             * Returns the `GtkWidget` in the button on the column header.
             *
             * If a custom widget has not been set then %NULL is returned.
             * @returns The `GtkWidget` in the column header
             */
            get_widget(): Widget | null;
            /**
             * Returns the current size of `tree_column` in pixels.
             * @returns The current width of @tree_column.
             */
            get_width(): number;
            /**
             * Returns the current X offset of `tree_column` in pixels.
             * @returns The current X offset of @tree_column.
             */
            get_x_offset(): number;
            /**
             * Adds the `cell` to end of the column. If `expand` is %FALSE, then the `cell`
             * is allocated no more space than it needs. Any unused space is divided
             * evenly between cells for which `expand` is %TRUE.
             * @param cell The `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @tree_column.
             */
            pack_end(cell: CellRenderer, expand: boolean): void;
            /**
             * Packs the `cell` into the beginning of the column. If `expand` is %FALSE, then
             * the `cell` is allocated no more space than it needs. Any unused space is divided
             * evenly between cells for which `expand` is %TRUE.
             * @param cell The `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @tree_column.
             */
            pack_start(cell: CellRenderer, expand: boolean): void;
            /**
             * Flags the column, and the cell renderers added to this column, to have
             * their sizes renegotiated.
             */
            queue_resize(): void;
            /**
             * Sets the alignment of the title or custom widget inside the column header.
             * The alignment determines its location inside the button -- 0.0 for left, 0.5
             * for center, 1.0 for right.
             * @param xalign The alignment, which is between [0.0 and 1.0] inclusive.
             */
            set_alignment(xalign: number): void;
            /**
             * Sets the `GtkTreeCellDataFunc` to use for the column.
             *
             * This
             * function is used instead of the standard attributes mapping for
             * setting the column value, and should set the value of `tree_column'`s
             * cell renderer as appropriate.  `func` may be %NULL to remove an
             * older one.
             * @param cell_renderer A `GtkCellRenderer`
             * @param func The `GtkTreeCellDataFunc` to use.
             */
            set_cell_data_func(cell_renderer: CellRenderer, func?: TreeCellDataFunc | null): void;
            // Conflicted with Gtk.CellLayout.set_cell_data_func
            set_cell_data_func(...args: never[]): any;
            /**
             * Sets the header to be active if `clickable` is %TRUE.  When the header is
             * active, then it can take keyboard focus, and can be clicked.
             * @param clickable %TRUE if the header is active.
             */
            set_clickable(clickable: boolean): void;
            /**
             * Sets the column to take available extra space.  This space is shared equally
             * amongst all columns that have the expand set to %TRUE.  If no column has this
             * option set, then the last column gets all extra space.  By default, every
             * column is created with this %FALSE.
             *
             * Along with “fixed-width”, the “expand” property changes when the column is
             * resized by the user.
             * @param expand %TRUE if the column should expand to fill available space.
             */
            set_expand(expand: boolean): void;
            /**
             * If `fixed_width` is not -1, sets the fixed width of `tree_column;` otherwise
             * unsets it.  The effective value of `fixed_width` is clamped between the
             * minimum and maximum width of the column; however, the value stored in the
             * “fixed-width” property is not clamped.  If the column sizing is
             * %GTK_TREE_VIEW_COLUMN_GROW_ONLY or %GTK_TREE_VIEW_COLUMN_AUTOSIZE, setting
             * a fixed width overrides the automatically calculated width.  Note that
             * `fixed_width` is only a hint to GTK; the width actually allocated to the
             * column may be greater or less than requested.
             *
             * Along with “expand”, the “fixed-width” property changes when the column is
             * resized by the user.
             * @param fixed_width The new fixed width, in pixels, or -1.
             */
            set_fixed_width(fixed_width: number): void;
            /**
             * Sets the maximum width of the `tree_column`.  If `max_width` is -1, then the
             * maximum width is unset.  Note, the column can actually be wider than max
             * width if it’s the last column in a view.  In this case, the column expands to
             * fill any extra space.
             * @param max_width The maximum width of the column in pixels, or -1.
             */
            set_max_width(max_width: number): void;
            /**
             * Sets the minimum width of the `tree_column`.  If `min_width` is -1, then the
             * minimum width is unset.
             * @param min_width The minimum width of the column in pixels, or -1.
             */
            set_min_width(min_width: number): void;
            /**
             * If `reorderable` is %TRUE, then the column can be reordered by the end user
             * dragging the header.
             * @param reorderable %TRUE, if the column can be reordered.
             */
            set_reorderable(reorderable: boolean): void;
            /**
             * If `resizable` is %TRUE, then the user can explicitly resize the column by
             * grabbing the outer edge of the column button.
             *
             * If resizable is %TRUE and
             * sizing mode of the column is %GTK_TREE_VIEW_COLUMN_AUTOSIZE, then the sizing
             * mode is changed to %GTK_TREE_VIEW_COLUMN_GROW_ONLY.
             * @param resizable %TRUE, if the column can be resized
             */
            set_resizable(resizable: boolean): void;
            /**
             * Sets the growth behavior of `tree_column` to `type`.
             * @param type The `GtkTreeViewColumn`Sizing.
             */
            set_sizing(type: TreeViewColumnSizing | null): void;
            /**
             * Sets the logical `sort_column_id` that this column sorts on when this column
             * is selected for sorting.  Doing so makes the column header clickable.
             * @param sort_column_id The @sort_column_id of the model to sort on.
             */
            set_sort_column_id(sort_column_id: number): void;
            /**
             * Call this function with a `setting` of %TRUE to display an arrow in
             * the header button indicating the column is sorted. Call
             * gtk_tree_view_column_set_sort_order() to change the direction of
             * the arrow.
             * @param setting %TRUE to display an indicator that the column is sorted
             */
            set_sort_indicator(setting: boolean): void;
            /**
             * Changes the appearance of the sort indicator.
             *
             * This does not actually sort the model.  Use
             * gtk_tree_view_column_set_sort_column_id() if you want automatic sorting
             * support.  This function is primarily for custom sorting behavior, and should
             * be used in conjunction with gtk_tree_sortable_set_sort_column_id() to do
             * that. For custom models, the mechanism will vary.
             *
             * The sort indicator changes direction to indicate normal sort or reverse sort.
             * Note that you must have the sort indicator enabled to see anything when
             * calling this function; see gtk_tree_view_column_set_sort_indicator().
             * @param order sort order that the sort indicator should indicate
             */
            set_sort_order(order: SortType | null): void;
            /**
             * Sets the spacing field of `tree_column,` which is the number of pixels to
             * place between cell renderers packed into it.
             * @param spacing distance between cell renderers in pixels.
             */
            set_spacing(spacing: number): void;
            /**
             * Sets the title of the `tree_column`.  If a custom widget has been set, then
             * this value is ignored.
             * @param title The title of the @tree_column.
             */
            set_title(title: string): void;
            /**
             * Sets the visibility of `tree_column`.
             * @param visible %TRUE if the @tree_column is visible.
             */
            set_visible(visible: boolean): void;
            /**
             * Sets the widget in the header to be `widget`.  If widget is %NULL, then the
             * header button is set with a `GtkLabel` set to the title of `tree_column`.
             * @param widget A child `GtkWidget`
             */
            set_widget(widget?: Widget | null): void;

            // Inherited methods
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Returns the underlying `GtkCellArea` which might be `cell_layout`
             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
             * is used by `cell_layout`.
             * @returns the cell area used by @cell_layout
             */
            get_area(): CellArea | null;
            /**
             * Returns the cell renderers which have been added to `cell_layout`.
             * @returns a list of cell renderers. The list, but not the renderers has   been newly allocated and should be freed with g_list_free()   when no longer needed.
             */
            get_cells(): CellRenderer[];
            /**
             * Re-inserts `cell` at `position`.
             *
             * Note that `cell` has already to be packed into `cell_layout`
             * for this to function properly.
             * @param cell a `GtkCellRenderer` to reorder
             * @param position new position to insert @cell at
             */
            reorder(cell: CellRenderer, position: number): void;
            /**
             * Adds an attribute mapping to the list in `cell_layout`.
             *
             * The `column` is the column of the model to get a value from, and the
             * `attribute` is the property on `cell` to be set from that value. So for
             * example if column 2 of the model contains strings, you could have the
             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
             * In this context "attribute" and "property" are used interchangeably.
             * @param cell a `GtkCellRenderer`
             * @param attribute a property on the renderer
             * @param column the column position on the model to get the attribute from
             */
            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
            /**
             * Unsets all the mappings on all renderers on `cell_layout` and
             * removes all renderers from `cell_layout`.
             */
            vfunc_clear(): void;
            /**
             * Clears all existing attributes previously set with
             * gtk_cell_layout_set_attributes().
             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
             */
            vfunc_clear_attributes(cell: CellRenderer): void;
            /**
             * Returns the underlying `GtkCellArea` which might be `cell_layout`
             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
             * is used by `cell_layout`.
             */
            vfunc_get_area(): CellArea | null;
            /**
             * Returns the cell renderers which have been added to `cell_layout`.
             */
            vfunc_get_cells(): CellRenderer[];
            /**
             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
             * `cell` is allocated no more space than it needs. Any unused space is
             * divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
            /**
             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
             * then the `cell` is allocated no more space than it needs. Any unused space
             * is divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
            /**
             * Re-inserts `cell` at `position`.
             *
             * Note that `cell` has already to be packed into `cell_layout`
             * for this to function properly.
             * @param cell a `GtkCellRenderer` to reorder
             * @param position new position to insert @cell at
             */
            vfunc_reorder(cell: CellRenderer, position: number): void;
            /**
             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
             *
             * This function is used instead of the standard attributes mapping
             * for setting the column value, and should set the value of `cell_layout’`s
             * cell renderer(s) as appropriate.
             *
             * `func` may be %NULL to remove a previously set function.
             * @param cell a `GtkCellRenderer`
             * @param func the `GtkCellLayout`DataFunc to use
             */
            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace UriLauncher {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                uri: string;
            }
        }

        /**
         * A `GtkUriLauncher` object collects the arguments that are needed to open a uri
         * with an application.
         *
         * Depending on system configuration, user preferences and available APIs, this
         * may or may not show an app chooser dialog or launch the default application
         * right away.
         *
         * The operation is started with the [method`Gtk`.UriLauncher.launch] function.
         *
         * To launch a file, use [class`Gtk`.FileLauncher].
         */
        class UriLauncher extends GObject.Object {
            static $gtype: GObject.GType<UriLauncher>;

            // Properties

            /**
             * The uri to launch.
             */
            get uri(): string;
            set uri(val: string);

            // Constructors

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

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

            static ['new'](uri?: string | null): UriLauncher;

            // Methods

            /**
             * Gets the uri that will be opened.
             * @returns the uri
             */
            get_uri(): string | null;
            /**
             * Launch an application to open the uri.
             *
             * This may present an app chooser dialog to the user.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             */
            launch(parent?: Window | null, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Launch an application to open the uri.
             *
             * This may present an app chooser dialog to the user.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            launch(
                parent: Window | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Launch an application to open the uri.
             *
             * This may present an app chooser dialog to the user.
             * @param parent the parent `GtkWindow`
             * @param cancellable a `GCancellable` to cancel the operation
             * @param callback a callback to call when the   operation is complete
             */
            launch(
                parent?: Window | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes the [method`Gtk`.UriLauncher.launch] call and
             * returns the result.
             * @param result a `GAsyncResult`
             * @returns `TRUE` if an application was launched,     or `FALSE` and @error is set
             */
            launch_finish(result: Gio.AsyncResult): boolean;
            /**
             * Sets the uri that will be opened.
             * @param uri the uri
             */
            set_uri(uri?: string | null): void;
        }

        namespace Video {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                autoplay: boolean;
                file: Gio.File;
                graphics_offload: GraphicsOffloadEnabled;
                graphicsOffload: GraphicsOffloadEnabled;
                loop: boolean;
                media_stream: MediaStream;
                mediaStream: MediaStream;
            }
        }

        /**
         * `GtkVideo` is a widget to show a `GtkMediaStream` with media controls.
         *
         * ![An example GtkVideo](video.png)
         *
         * The controls are available separately as [class`Gtk`.MediaControls].
         * If you just want to display a video without controls, you can treat it
         * like any other paintable and for example put it into a [class`Gtk`.Picture].
         *
         * `GtkVideo` aims to cover use cases such as previews, embedded animations,
         * etc. It supports autoplay, looping, and simple media controls. It does
         * not have support for video overlays, multichannel audio, device
         * selection, or input. If you are writing a full-fledged video player,
         * you may want to use the [iface`Gdk`.Paintable] API and a media framework
         * such as Gstreamer directly.
         */
        class Video extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<Video>;

            // Properties

            /**
             * If the video should automatically begin playing.
             */
            get autoplay(): boolean;
            set autoplay(val: boolean);
            /**
             * The file played by this video if the video is playing a file.
             */
            get file(): Gio.File;
            set file(val: Gio.File);
            /**
             * Whether to enable graphics offload.
             */
            get graphics_offload(): GraphicsOffloadEnabled;
            set graphics_offload(val: GraphicsOffloadEnabled);
            /**
             * Whether to enable graphics offload.
             */
            get graphicsOffload(): GraphicsOffloadEnabled;
            set graphicsOffload(val: GraphicsOffloadEnabled);
            /**
             * If new media files should be set to loop.
             */
            get loop(): boolean;
            set loop(val: boolean);
            /**
             * The media-stream played
             */
            get media_stream(): MediaStream;
            set media_stream(val: MediaStream);
            /**
             * The media-stream played
             */
            get mediaStream(): MediaStream;
            set mediaStream(val: MediaStream);

            // Constructors

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

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

            static ['new'](): Video;

            static new_for_file(file?: Gio.File | null): Video;

            static new_for_filename(filename?: string | null): Video;

            static new_for_media_stream(stream?: MediaStream | null): Video;

            static new_for_resource(resource_path?: string | null): Video;

            // Methods

            /**
             * Returns %TRUE if videos have been set to loop.
             * @returns %TRUE if streams should autoplay
             */
            get_autoplay(): boolean;
            /**
             * Gets the file played by `self` or %NULL if not playing back
             * a file.
             * @returns The file played by @self
             */
            get_file(): Gio.File | null;
            /**
             * Returns whether graphics offload is enabled.
             *
             * See [class`Gtk`.GraphicsOffload] for more information on graphics offload.
             * @returns the graphics offload status
             */
            get_graphics_offload(): GraphicsOffloadEnabled;
            /**
             * Returns %TRUE if videos have been set to loop.
             * @returns %TRUE if streams should loop
             */
            get_loop(): boolean;
            /**
             * Gets the media stream managed by `self` or %NULL if none.
             * @returns The media stream managed by @self
             */
            get_media_stream(): MediaStream | null;
            /**
             * Sets whether `self` automatically starts playback when it
             * becomes visible or when a new file gets loaded.
             * @param autoplay whether media streams should autoplay
             */
            set_autoplay(autoplay: boolean): void;
            /**
             * Makes `self` play the given `file`.
             * @param file the file to play
             */
            set_file(file?: Gio.File | null): void;
            /**
             * Makes `self` play the given `filename`.
             *
             * This is a utility function that calls gtk_video_set_file(),
             * @param filename the filename to play
             */
            set_filename(filename?: string | null): void;
            /**
             * Sets whether to enable graphics offload.
             *
             * See [class`Gtk`.GraphicsOffload] for more information on graphics offload.
             * @param enabled the new graphics offload status
             */
            set_graphics_offload(enabled: GraphicsOffloadEnabled | null): void;
            /**
             * Sets whether new files loaded by `self` should be set to loop.
             * @param loop whether media streams should loop
             */
            set_loop(loop: boolean): void;
            /**
             * Sets the media stream to be played back.
             *
             * `self` will take full control of managing the media stream. If you
             * want to manage a media stream yourself, consider using a
             * [class`Gtk`.Picture] for display.
             *
             * If you want to display a file, consider using [method`Gtk`.Video.set_file]
             * instead.
             * @param stream The media stream to play or %NULL to unset
             */
            set_media_stream(stream?: MediaStream | null): void;
            /**
             * Makes `self` play the resource at the given `resource_path`.
             *
             * This is a utility function that calls [method`Gtk`.Video.set_file].
             * @param resource_path the resource to set
             */
            set_resource(resource_path?: string | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Viewport {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Scrollable.ConstructorProps {
                child: Widget;
                scroll_to_focus: boolean;
                scrollToFocus: boolean;
            }
        }

        /**
         * `GtkViewport` implements scrollability for widgets that lack their
         * own scrolling capabilities.
         *
         * Use `GtkViewport` to scroll child widgets such as `GtkGrid`,
         * `GtkBox`, and so on.
         *
         * The `GtkViewport` will start scrolling content only if allocated
         * less than the child widget’s minimum size in a given orientation.
         *
         * # CSS nodes
         *
         * `GtkViewport` has a single CSS node with name `viewport`.
         *
         * # Accessibility
         *
         * Until GTK 4.10, `GtkViewport` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
         *
         * Starting from GTK 4.12, `GtkViewport` uses the `GTK_ACCESSIBLE_ROLE_GENERIC` role.
         */
        class Viewport extends Widget implements Accessible, Buildable, ConstraintTarget, Scrollable {
            static $gtype: GObject.GType<Viewport>;

            // Properties

            /**
             * The child widget.
             */
            get child(): Widget;
            set child(val: Widget);
            /**
             * Whether to scroll when the focus changes.
             *
             * Before 4.6.2, this property was mistakenly defaulting to FALSE, so if your
             * code needs to work with older versions, consider setting it explicitly to
             * TRUE.
             */
            get scroll_to_focus(): boolean;
            set scroll_to_focus(val: boolean);
            /**
             * Whether to scroll when the focus changes.
             *
             * Before 4.6.2, this property was mistakenly defaulting to FALSE, so if your
             * code needs to work with older versions, consider setting it explicitly to
             * TRUE.
             */
            get scrollToFocus(): boolean;
            set scrollToFocus(val: boolean);

            // Constructors

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

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

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

            // Methods

            /**
             * Gets the child widget of `viewport`.
             * @returns the child widget of @viewport
             */
            get_child(): Widget | null;
            /**
             * Gets whether the viewport is scrolling to keep the focused
             * child in view.
             * @returns %TRUE if the viewport keeps the focus child scrolled to view
             */
            get_scroll_to_focus(): boolean;
            /**
             * Scrolls a descendant of the viewport into view.
             *
             * The viewport and the descendant must be visible and mapped for
             * this function to work, otherwise no scrolling will be performed.
             * @param descendant a descendant widget of the viewport
             * @param scroll details of how to perform   the scroll operation or NULL to scroll into view
             */
            scroll_to(descendant: Widget, scroll?: ScrollInfo | null): void;
            /**
             * Sets the child widget of `viewport`.
             * @param child the child widget
             */
            set_child(child?: Widget | null): void;
            /**
             * Sets whether the viewport should automatically scroll
             * to keep the focused child in view.
             * @param scroll_to_focus whether to keep the focus widget scrolled to view
             */
            set_scroll_to_focus(scroll_to_focus: boolean): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * Horizontal `GtkAdjustment` of the scrollable widget.
             *
             * This adjustment is shared between the scrollable widget and its parent.
             */
            get hadjustment(): Adjustment;
            set hadjustment(val: Adjustment);
            /**
             * Determines when horizontal scrolling should start.
             */
            get hscroll_policy(): ScrollablePolicy;
            set hscroll_policy(val: ScrollablePolicy);
            /**
             * Determines when horizontal scrolling should start.
             */
            get hscrollPolicy(): ScrollablePolicy;
            set hscrollPolicy(val: ScrollablePolicy);
            /**
             * Vertical `GtkAdjustment` of the scrollable widget.
             *
             * This adjustment is shared between the scrollable widget and its parent.
             */
            get vadjustment(): Adjustment;
            set vadjustment(val: Adjustment);
            /**
             * Determines when vertical scrolling should start.
             */
            get vscroll_policy(): ScrollablePolicy;
            set vscroll_policy(val: ScrollablePolicy);
            /**
             * Determines when vertical scrolling should start.
             */
            get vscrollPolicy(): ScrollablePolicy;
            set vscrollPolicy(val: ScrollablePolicy);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Returns the size of a non-scrolling border around the
             * outside of the scrollable.
             *
             * An example for this would be treeview headers. GTK can use
             * this information to display overlaid graphics, like the
             * overshoot indication, at the right position.
             * @returns %TRUE if @border has been set
             */
            get_border(): [boolean, Border];
            /**
             * Retrieves the `GtkAdjustment` used for horizontal scrolling.
             * @returns horizontal `GtkAdjustment`.
             */
            get_hadjustment(): Adjustment | null;
            /**
             * Gets the horizontal `GtkScrollablePolicy`.
             * @returns The horizontal `GtkScrollablePolicy`.
             */
            get_hscroll_policy(): ScrollablePolicy;
            /**
             * Retrieves the `GtkAdjustment` used for vertical scrolling.
             * @returns vertical `GtkAdjustment`.
             */
            get_vadjustment(): Adjustment | null;
            /**
             * Gets the vertical `GtkScrollablePolicy`.
             * @returns The vertical `GtkScrollablePolicy`.
             */
            get_vscroll_policy(): ScrollablePolicy;
            /**
             * Sets the horizontal adjustment of the `GtkScrollable`.
             * @param hadjustment a `GtkAdjustment`
             */
            set_hadjustment(hadjustment?: Adjustment | null): void;
            /**
             * Sets the `GtkScrollablePolicy`.
             *
             * The policy determines whether horizontal scrolling should start
             * below the minimum width or below the natural width.
             * @param policy the horizontal `GtkScrollablePolicy`
             */
            set_hscroll_policy(policy: ScrollablePolicy | null): void;
            /**
             * Sets the vertical adjustment of the `GtkScrollable`.
             * @param vadjustment a `GtkAdjustment`
             */
            set_vadjustment(vadjustment?: Adjustment | null): void;
            /**
             * Sets the `GtkScrollablePolicy`.
             *
             * The policy determines whether vertical scrolling should start
             * below the minimum height or below the natural height.
             * @param policy the vertical `GtkScrollablePolicy`
             */
            set_vscroll_policy(policy: ScrollablePolicy | null): void;
            /**
             * Returns the size of a non-scrolling border around the
             * outside of the scrollable.
             *
             * An example for this would be treeview headers. GTK can use
             * this information to display overlaid graphics, like the
             * overshoot indication, at the right position.
             */
            vfunc_get_border(): [boolean, Border];
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace VolumeButton {
            // Constructor properties interface

            interface ConstructorProps
                extends ScaleButton.ConstructorProps,
                    Accessible.ConstructorProps,
                    AccessibleRange.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Orientable.ConstructorProps {
                use_symbolic: boolean;
                useSymbolic: boolean;
            }
        }

        /**
         * `GtkVolumeButton` is a `GtkScaleButton` subclass tailored for
         * volume control.
         *
         * ![An example GtkVolumeButton](volumebutton.png)
         */
        class VolumeButton
            extends ScaleButton
            implements Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable
        {
            static $gtype: GObject.GType<VolumeButton>;

            // Properties

            /**
             * Whether to use symbolic icons as the icons.
             *
             * Note that if the symbolic icons are not available in your installed
             * theme, then the normal (potentially colorful) icons will be used.
             */
            get use_symbolic(): boolean;
            set use_symbolic(val: boolean);
            /**
             * Whether to use symbolic icons as the icons.
             *
             * Note that if the symbolic icons are not available in your installed
             * theme, then the normal (potentially colorful) icons will be used.
             */
            get useSymbolic(): boolean;
            set useSymbolic(val: boolean);

            // Constructors

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

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

            static ['new'](): VolumeButton;

            // Inherited properties
            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Inherited methods
            /**
             * Sets the current value of the accessible range.
             *
             * This operation should behave similarly as if the user performed the
             * action.
             * @param value the value to set
             */
            vfunc_set_current_value(value: number): boolean;
            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Widget {
            // Signal callback interfaces

            interface Destroy {
                (): void;
            }

            interface DirectionChanged {
                (previous_direction: TextDirection): void;
            }

            interface Hide {
                (): void;
            }

            interface KeynavFailed {
                (direction: DirectionType): boolean;
            }

            interface Map {
                (): void;
            }

            interface MnemonicActivate {
                (group_cycling: boolean): boolean;
            }

            interface MoveFocus {
                (direction: DirectionType): void;
            }

            interface QueryTooltip {
                (x: number, y: number, keyboard_mode: boolean, tooltip: Tooltip): boolean;
            }

            interface Realize {
                (): void;
            }

            interface Show {
                (): void;
            }

            interface StateFlagsChanged {
                (flags: StateFlags): void;
            }

            interface Unmap {
                (): void;
            }

            interface Unrealize {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends GObject.InitiallyUnowned.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                can_focus: boolean;
                canFocus: boolean;
                can_target: boolean;
                canTarget: boolean;
                css_classes: string[];
                cssClasses: string[];
                css_name: string;
                cssName: string;
                cursor: Gdk.Cursor;
                focus_on_click: boolean;
                focusOnClick: boolean;
                focusable: boolean;
                halign: Align;
                has_default: boolean;
                hasDefault: boolean;
                has_focus: boolean;
                hasFocus: boolean;
                has_tooltip: boolean;
                hasTooltip: boolean;
                height_request: number;
                heightRequest: number;
                hexpand: boolean;
                hexpand_set: boolean;
                hexpandSet: boolean;
                layout_manager: LayoutManager;
                layoutManager: LayoutManager;
                margin_bottom: number;
                marginBottom: number;
                margin_end: number;
                marginEnd: number;
                margin_start: number;
                marginStart: number;
                margin_top: number;
                marginTop: number;
                name: string;
                opacity: number;
                overflow: Overflow;
                parent: Widget;
                receives_default: boolean;
                receivesDefault: boolean;
                root: Root;
                scale_factor: number;
                scaleFactor: number;
                sensitive: boolean;
                tooltip_markup: string;
                tooltipMarkup: string;
                tooltip_text: string;
                tooltipText: string;
                valign: Align;
                vexpand: boolean;
                vexpand_set: boolean;
                vexpandSet: boolean;
                visible: boolean;
                width_request: number;
                widthRequest: number;
            }
        }

        /**
         * The base class for all widgets.
         *
         * `GtkWidget` is the base class all widgets in GTK derive from. It manages the
         * widget lifecycle, layout, states and style.
         *
         * ### Height-for-width Geometry Management
         *
         * GTK uses a height-for-width (and width-for-height) geometry management
         * system. Height-for-width means that a widget can change how much
         * vertical space it needs, depending on the amount of horizontal space
         * that it is given (and similar for width-for-height). The most common
         * example is a label that reflows to fill up the available width, wraps
         * to fewer lines, and therefore needs less height.
         *
         * Height-for-width geometry management is implemented in GTK by way
         * of two virtual methods:
         *
         * - [vfunc`Gtk`.Widget.get_request_mode]
         * - [vfunc`Gtk`.Widget.measure]
         *
         * There are some important things to keep in mind when implementing
         * height-for-width and when using it in widget implementations.
         *
         * If you implement a direct `GtkWidget` subclass that supports
         * height-for-width or width-for-height geometry management for itself
         * or its child widgets, the [vfunc`Gtk`.Widget.get_request_mode] virtual
         * function must be implemented as well and return the widget's preferred
         * request mode. The default implementation of this virtual function
         * returns %GTK_SIZE_REQUEST_CONSTANT_SIZE, which means that the widget will
         * only ever get -1 passed as the for_size value to its
         * [vfunc`Gtk`.Widget.measure] implementation.
         *
         * The geometry management system will query a widget hierarchy in
         * only one orientation at a time. When widgets are initially queried
         * for their minimum sizes it is generally done in two initial passes
         * in the [enum`Gtk`.SizeRequestMode] chosen by the toplevel.
         *
         * For example, when queried in the normal %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH mode:
         *
         * First, the default minimum and natural width for each widget
         * in the interface will be computed using [method`Gtk`.Widget.measure] with an
         * orientation of %GTK_ORIENTATION_HORIZONTAL and a for_size of -1.
         * Because the preferred widths for each widget depend on the preferred
         * widths of their children, this information propagates up the hierarchy,
         * and finally a minimum and natural width is determined for the entire
         * toplevel. Next, the toplevel will use the minimum width to query for the
         * minimum height contextual to that width using [method`Gtk`.Widget.measure] with an
         * orientation of %GTK_ORIENTATION_VERTICAL and a for_size of the just computed
         * width. This will also be a highly recursive operation. The minimum height
         * for the minimum width is normally used to set the minimum size constraint
         * on the toplevel.
         *
         * After the toplevel window has initially requested its size in both
         * dimensions it can go on to allocate itself a reasonable size (or a size
         * previously specified with [method`Gtk`.Window.set_default_size]). During the
         * recursive allocation process it’s important to note that request cycles
         * will be recursively executed while widgets allocate their children.
         * Each widget, once allocated a size, will go on to first share the
         * space in one orientation among its children and then request each child's
         * height for its target allocated width or its width for allocated height,
         * depending. In this way a `GtkWidget` will typically be requested its size
         * a number of times before actually being allocated a size. The size a
         * widget is finally allocated can of course differ from the size it has
         * requested. For this reason, `GtkWidget` caches a  small number of results
         * to avoid re-querying for the same sizes in one allocation cycle.
         *
         * If a widget does move content around to intelligently use up the
         * allocated size then it must support the request in both
         * `GtkSizeRequestMode`s even if the widget in question only
         * trades sizes in a single orientation.
         *
         * For instance, a [class`Gtk`.Label] that does height-for-width word wrapping
         * will not expect to have [vfunc`Gtk`.Widget.measure] with an orientation of
         * %GTK_ORIENTATION_VERTICAL called because that call is specific to a
         * width-for-height request. In this case the label must return the height
         * required for its own minimum possible width. By following this rule any
         * widget that handles height-for-width or width-for-height requests will
         * always be allocated at least enough space to fit its own content.
         *
         * Here are some examples of how a %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH widget
         * generally deals with width-for-height requests:
         *
         * ```c
         * static void
         * foo_widget_measure (GtkWidget      *widget,
         *                     GtkOrientation  orientation,
         *                     int             for_size,
         *                     int            *minimum_size,
         *                     int            *natural_size,
         *                     int            *minimum_baseline,
         *                     int            *natural_baseline)
         * {
         *   if (orientation == GTK_ORIENTATION_HORIZONTAL)
         *     {
         *       // Calculate minimum and natural width
         *     }
         *   else // VERTICAL
         *     {
         *       if (i_am_in_height_for_width_mode)
         *         {
         *           int min_width, dummy;
         *
         *           // First, get the minimum width of our widget
         *           GTK_WIDGET_GET_CLASS (widget)->measure (widget, GTK_ORIENTATION_HORIZONTAL, -1,
         *                                                   &min_width, &dummy, &dummy, &dummy);
         *
         *           // Now use the minimum width to retrieve the minimum and natural height to display
         *           // that width.
         *           GTK_WIDGET_GET_CLASS (widget)->measure (widget, GTK_ORIENTATION_VERTICAL, min_width,
         *                                                   minimum_size, natural_size, &dummy, &dummy);
         *         }
         *       else
         *         {
         *           // ... some widgets do both.
         *         }
         *     }
         * }
         * ```
         *
         * Often a widget needs to get its own request during size request or
         * allocation. For example, when computing height it may need to also
         * compute width. Or when deciding how to use an allocation, the widget
         * may need to know its natural size. In these cases, the widget should
         * be careful to call its virtual methods directly, like in the code
         * example above.
         *
         * It will not work to use the wrapper function [method`Gtk`.Widget.measure]
         * inside your own [vfunc`Gtk`.Widget.size_allocate] implementation.
         * These return a request adjusted by [class`Gtk`.SizeGroup], the widget's
         * align and expand flags, as well as its CSS style.
         *
         * If a widget used the wrappers inside its virtual method implementations,
         * then the adjustments (such as widget margins) would be applied
         * twice. GTK therefore does not allow this and will warn if you try
         * to do it.
         *
         * Of course if you are getting the size request for another widget, such
         * as a child widget, you must use [method`Gtk`.Widget.measure]; otherwise, you
         * would not properly consider widget margins, [class`Gtk`.SizeGroup], and
         * so forth.
         *
         * GTK also supports baseline vertical alignment of widgets. This
         * means that widgets are positioned such that the typographical baseline of
         * widgets in the same row are aligned. This happens if a widget supports
         * baselines, has a vertical alignment using baselines, and is inside
         * a widget that supports baselines and has a natural “row” that it aligns to
         * the baseline, or a baseline assigned to it by the grandparent.
         *
         * Baseline alignment support for a widget is also done by the
         * [vfunc`Gtk`.Widget.measure] virtual function. It allows you to report
         * both a minimum and natural size.
         *
         * If a widget ends up baseline aligned it will be allocated all the space in
         * the parent as if it was %GTK_ALIGN_FILL, but the selected baseline can be
         * found via [method`Gtk`.Widget.get_baseline]. If the baseline has a
         * value other than -1 you need to align the widget such that the baseline
         * appears at the position.
         *
         * ### GtkWidget as GtkBuildable
         *
         * The `GtkWidget` implementation of the `GtkBuildable` interface
         * supports various custom elements to specify additional aspects of widgets
         * that are not directly expressed as properties.
         *
         * If the widget uses a [class`Gtk`.LayoutManager], `GtkWidget` supports
         * a custom `<layout>` element, used to define layout properties:
         *
         * ```xml
         * <object class="GtkGrid" id="my_grid">
         *   <child>
         *     <object class="GtkLabel" id="label1">
         *       <property name="label">Description</property>
         *       <layout>
         *         <property name="column">0</property>
         *         <property name="row">0</property>
         *         <property name="row-span">1</property>
         *         <property name="column-span">1</property>
         *       </layout>
         *     </object>
         *   </child>
         *   <child>
         *     <object class="GtkEntry" id="description_entry">
         *       <layout>
         *         <property name="column">1</property>
         *         <property name="row">0</property>
         *         <property name="row-span">1</property>
         *         <property name="column-span">1</property>
         *       </layout>
         *     </object>
         *   </child>
         * </object>
         * ```
         *
         * `GtkWidget` allows style information such as style classes to
         * be associated with widgets, using the custom `<style>` element:
         *
         * ```xml
         * <object class="GtkButton" id="button1">
         *   <style>
         *     <class name="my-special-button-class"/>
         *     <class name="dark-button"/>
         *   </style>
         * </object>
         * ```
         *
         * `GtkWidget` allows defining accessibility information, such as properties,
         * relations, and states, using the custom `<accessibility>` element:
         *
         * ```xml
         * <object class="GtkButton" id="button1">
         *   <accessibility>
         *     <property name="label">Download</property>
         *     <relation name="labelled-by">label1</relation>
         *   </accessibility>
         * </object>
         * ```
         *
         * ### Building composite widgets from template XML
         *
         * `GtkWidget `exposes some facilities to automate the procedure
         * of creating composite widgets using "templates".
         *
         * To create composite widgets with `GtkBuilder` XML, one must associate
         * the interface description with the widget class at class initialization
         * time using [method`Gtk`.WidgetClass.set_template].
         *
         * The interface description semantics expected in composite template descriptions
         * is slightly different from regular [class`Gtk`.Builder] XML.
         *
         * Unlike regular interface descriptions, [method`Gtk`.WidgetClass.set_template]
         * will expect a `<template>` tag as a direct child of the toplevel
         * `<interface>` tag. The `<template>` tag must specify the “class” attribute
         * which must be the type name of the widget. Optionally, the “parent”
         * attribute may be specified to specify the direct parent type of the widget
         * type; this is ignored by `GtkBuilder` but can be used by UI design tools to
         * introspect what kind of properties and internal children exist for a given
         * type when the actual type does not exist.
         *
         * The XML which is contained inside the `<template>` tag behaves as if it were
         * added to the `<object>` tag defining the widget itself. You may set properties
         * on a widget by inserting `<property>` tags into the `<template>` tag, and also
         * add `<child>` tags to add children and extend a widget in the normal way you
         * would with `<object>` tags.
         *
         * Additionally, `<object>` tags can also be added before and after the initial
         * `<template>` tag in the normal way, allowing one to define auxiliary objects
         * which might be referenced by other widgets declared as children of the
         * `<template>` tag.
         *
         * Since, unlike the `<object>` tag, the `<template>` tag does not contain an
         * “id” attribute, if you need to refer to the instance of the object itself that
         * the template will create, simply refer to the template class name in an
         * applicable element content.
         *
         * Here is an example of a template definition, which includes an example of
         * this in the `<signal>` tag:
         *
         * ```xml
         * <interface>
         *   <template class="FooWidget" parent="GtkBox">
         *     <property name="orientation">horizontal</property>
         *     <property name="spacing">4</property>
         *     <child>
         *       <object class="GtkButton" id="hello_button">
         *         <property name="label">Hello World</property>
         *         <signal name="clicked" handler="hello_button_clicked" object="FooWidget" swapped="yes"/>
         *       </object>
         *     </child>
         *     <child>
         *       <object class="GtkButton" id="goodbye_button">
         *         <property name="label">Goodbye World</property>
         *       </object>
         *     </child>
         *   </template>
         * </interface>
         * ```
         *
         * Typically, you'll place the template fragment into a file that is
         * bundled with your project, using `GResource`. In order to load the
         * template, you need to call [method`Gtk`.WidgetClass.set_template_from_resource]
         * from the class initialization of your `GtkWidget` type:
         *
         * ```c
         * static void
         * foo_widget_class_init (FooWidgetClass *klass)
         * {
         *   // ...
         *
         *   gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
         *                                                "/com/example/ui/foowidget.ui");
         * }
         * ```
         *
         * You will also need to call [method`Gtk`.Widget.init_template] from the
         * instance initialization function:
         *
         * ```c
         * static void
         * foo_widget_init (FooWidget *self)
         * {
         *   gtk_widget_init_template (GTK_WIDGET (self));
         *
         *   // Initialize the rest of the widget...
         * }
         * ```
         *
         * as well as calling [method`Gtk`.Widget.dispose_template] from the dispose
         * function:
         *
         * ```c
         * static void
         * foo_widget_dispose (GObject *gobject)
         * {
         *   FooWidget *self = FOO_WIDGET (gobject);
         *
         *   // Dispose objects for which you have a reference...
         *
         *   // Clear the template children for this widget type
         *   gtk_widget_dispose_template (GTK_WIDGET (self), FOO_TYPE_WIDGET);
         *
         *   G_OBJECT_CLASS (foo_widget_parent_class)->dispose (gobject);
         * }
         * ```
         *
         * You can access widgets defined in the template using the
         * [method`Gtk`.Widget.get_template_child] function, but you will typically declare
         * a pointer in the instance private data structure of your type using the same
         * name as the widget in the template definition, and call
         * [method`Gtk`.WidgetClass.bind_template_child_full] (or one of its wrapper macros
         * [func`Gtk`.widget_class_bind_template_child] and [func`Gtk`.widget_class_bind_template_child_private])
         * with that name, e.g.
         *
         * ```c
         * typedef struct {
         *   GtkWidget *hello_button;
         *   GtkWidget *goodbye_button;
         * } FooWidgetPrivate;
         *
         * G_DEFINE_TYPE_WITH_PRIVATE (FooWidget, foo_widget, GTK_TYPE_BOX)
         *
         * static void
         * foo_widget_dispose (GObject *gobject)
         * {
         *   gtk_widget_dispose_template (GTK_WIDGET (gobject), FOO_TYPE_WIDGET);
         *
         *   G_OBJECT_CLASS (foo_widget_parent_class)->dispose (gobject);
         * }
         *
         * static void
         * foo_widget_class_init (FooWidgetClass *klass)
         * {
         *   // ...
         *   G_OBJECT_CLASS (klass)->dispose = foo_widget_dispose;
         *
         *   gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
         *                                                "/com/example/ui/foowidget.ui");
         *   gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass),
         *                                                 FooWidget, hello_button);
         *   gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass),
         *                                                 FooWidget, goodbye_button);
         * }
         *
         * static void
         * foo_widget_init (FooWidget *widget)
         * {
         *   gtk_widget_init_template (GTK_WIDGET (widget));
         * }
         * ```
         *
         * You can also use [method`Gtk`.WidgetClass.bind_template_callback_full] (or
         * is wrapper macro [func`Gtk`.widget_class_bind_template_callback]) to connect
         * a signal callback defined in the template with a function visible in the
         * scope of the class, e.g.
         *
         * ```c
         * // the signal handler has the instance and user data swapped
         * // because of the swapped="yes" attribute in the template XML
         * static void
         * hello_button_clicked (FooWidget *self,
         *                       GtkButton *button)
         * {
         *   g_print ("Hello, world!\n");
         * }
         *
         * static void
         * foo_widget_class_init (FooWidgetClass *klass)
         * {
         *   // ...
         *   gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
         *                                                "/com/example/ui/foowidget.ui");
         *   gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (klass), hello_button_clicked);
         * }
         * ```
         */
        abstract class Widget extends GObject.InitiallyUnowned implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<Widget>;

            // Properties

            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Fields

            /**
             * Gtk.Widget is an iterable of its children.
             */
            [Symbol.iterator]: () => IterableIterator<Widget>;

            // Constructors

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

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

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'destroy', callback: (_source: this) => void): number;
            connect_after(signal: 'destroy', callback: (_source: this) => void): number;
            emit(signal: 'destroy'): void;
            connect(
                signal: 'direction-changed',
                callback: (_source: this, previous_direction: TextDirection) => void,
            ): number;
            connect_after(
                signal: 'direction-changed',
                callback: (_source: this, previous_direction: TextDirection) => void,
            ): number;
            emit(signal: 'direction-changed', previous_direction: TextDirection): void;
            connect(signal: 'hide', callback: (_source: this) => void): number;
            connect_after(signal: 'hide', callback: (_source: this) => void): number;
            emit(signal: 'hide'): void;
            connect(signal: 'keynav-failed', callback: (_source: this, direction: DirectionType) => boolean): number;
            connect_after(
                signal: 'keynav-failed',
                callback: (_source: this, direction: DirectionType) => boolean,
            ): number;
            emit(signal: 'keynav-failed', direction: DirectionType): void;
            connect(signal: 'map', callback: (_source: this) => void): number;
            connect_after(signal: 'map', callback: (_source: this) => void): number;
            emit(signal: 'map'): void;
            connect(signal: 'mnemonic-activate', callback: (_source: this, group_cycling: boolean) => boolean): number;
            connect_after(
                signal: 'mnemonic-activate',
                callback: (_source: this, group_cycling: boolean) => boolean,
            ): number;
            emit(signal: 'mnemonic-activate', group_cycling: boolean): void;
            connect(signal: 'move-focus', callback: (_source: this, direction: DirectionType) => void): number;
            connect_after(signal: 'move-focus', callback: (_source: this, direction: DirectionType) => void): number;
            emit(signal: 'move-focus', direction: DirectionType): void;
            connect(
                signal: 'query-tooltip',
                callback: (_source: this, x: number, y: number, keyboard_mode: boolean, tooltip: Tooltip) => boolean,
            ): number;
            connect_after(
                signal: 'query-tooltip',
                callback: (_source: this, x: number, y: number, keyboard_mode: boolean, tooltip: Tooltip) => boolean,
            ): number;
            emit(signal: 'query-tooltip', x: number, y: number, keyboard_mode: boolean, tooltip: Tooltip): void;
            connect(signal: 'realize', callback: (_source: this) => void): number;
            connect_after(signal: 'realize', callback: (_source: this) => void): number;
            emit(signal: 'realize'): void;
            connect(signal: 'show', callback: (_source: this) => void): number;
            connect_after(signal: 'show', callback: (_source: this) => void): number;
            emit(signal: 'show'): void;
            connect(signal: 'state-flags-changed', callback: (_source: this, flags: StateFlags) => void): number;
            connect_after(signal: 'state-flags-changed', callback: (_source: this, flags: StateFlags) => void): number;
            emit(signal: 'state-flags-changed', flags: StateFlags): void;
            connect(signal: 'unmap', callback: (_source: this) => void): number;
            connect_after(signal: 'unmap', callback: (_source: this) => void): number;
            emit(signal: 'unmap'): void;
            connect(signal: 'unrealize', callback: (_source: this) => void): number;
            connect_after(signal: 'unrealize', callback: (_source: this) => void): number;
            emit(signal: 'unrealize'): void;

            // Static methods

            /**
             * Obtains the current default reading direction.
             *
             * See [func`Gtk`.Widget.set_default_direction].
             */
            static get_default_direction(): TextDirection;
            /**
             * Sets the default reading direction for widgets.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @param dir the new default direction. This cannot be %GTK_TEXT_DIR_NONE.
             */
            static set_default_direction(dir: TextDirection): void;
            static add_shortcut(shortcut: Shortcut): void;
            static bind_template_callback_full(callback_name: string, callback_symbol: GObject.Callback): void;
            static bind_template_child_full(name: string, internal_child: boolean, struct_offset: number): void;
            static get_accessible_role(): AccessibleRole;
            static get_activate_signal(): number;
            static get_css_name(): string;
            static get_layout_manager_type(): GObject.GType;
            static install_action(
                action_name: string,
                parameter_type: string | null,
                activate: WidgetActionActivateFunc,
            ): void;
            static install_property_action(action_name: string, property_name: string): void;
            static query_action(index_: number): [boolean, GObject.GType, string, GLib.VariantType | null, string];
            static set_accessible_role(accessible_role: AccessibleRole): void;
            static set_activate_signal(signal_id: number): void;
            static set_activate_signal_from_name(signal_name: string): void;
            static set_css_name(name: string): void;
            static set_layout_manager_type(type: GObject.GType): void;
            static set_template(template_bytes: GLib.Bytes | Uint8Array): void;
            static set_template_from_resource(resource_name: string): void;
            static set_template_scope(scope: BuilderScope): void;

            // Virtual methods

            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;

            // Methods

            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Get the `GdkDisplay` for the toplevel window associated with
             * this widget.
             *
             * This function can only be called after the widget has been
             * added to a widget hierarchy with a `GtkWindow` at the top.
             *
             * In general, you should only create display specific
             * resources when a widget has been realized, and you should
             * free those resources when the widget is unrealized.
             * @returns the `GdkDisplay` for the toplevel   for this widget.
             */
            get_display(): Gdk.Display;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            realize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            unrealize(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace WidgetPaintable {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps, Gdk.Paintable.ConstructorProps {
                widget: Widget;
            }
        }

        /**
         * `GtkWidgetPaintable` is a `GdkPaintable` that displays the contents
         * of a widget.
         *
         * `GtkWidgetPaintable` will also take care of the widget not being in a
         * state where it can be drawn (like when it isn't shown) and just draw
         * nothing or where it does not have a size (like when it is hidden) and
         * report no size in that case.
         *
         * Of course, `GtkWidgetPaintable` allows you to monitor widgets for size
         * changes by emitting the [signal`Gdk`.Paintable::invalidate-size] signal
         * whenever the size of the widget changes as well as for visual changes by
         * emitting the [signal`Gdk`.Paintable::invalidate-contents] signal whenever
         * the widget changes.
         *
         * You can use a `GtkWidgetPaintable` everywhere a `GdkPaintable` is allowed,
         * including using it on a `GtkPicture` (or one of its parents) that it was
         * set on itself via gtk_picture_set_paintable(). The paintable will take care
         * of recursion when this happens. If you do this however, ensure that the
         * [property`Gtk`.Picture:can-shrink] property is set to %TRUE or you might
         * end up with an infinitely growing widget.
         */
        class WidgetPaintable extends GObject.Object implements Gdk.Paintable {
            static $gtype: GObject.GType<WidgetPaintable>;

            // Properties

            /**
             * The observed widget or %NULL if none.
             */
            get widget(): Widget;
            set widget(val: Widget);

            // Constructors

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

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

            static ['new'](widget?: Widget | null): WidgetPaintable;

            // Methods

            /**
             * Returns the widget that is observed or %NULL if none.
             * @returns the observed widget.
             */
            get_widget(): Widget | null;
            /**
             * Sets the widget that should be observed.
             * @param widget the widget to observe
             */
            set_widget(widget?: Widget | null): void;

            // Inherited methods
            /**
             * Compute a concrete size for the `GdkPaintable`.
             *
             * Applies the sizing algorithm outlined in the
             * [CSS Image spec](https://drafts.csswg.org/css-images-3/#default-sizing)
             * to the given `paintable`. See that link for more details.
             *
             * It is not necessary to call this function when both `specified_width`
             * and `specified_height` are known, but it is useful to call this
             * function in GtkWidget:measure implementations to compute the
             * other dimension when only one dimension is given.
             * @param specified_width the width @paintable could be drawn into or   0.0 if unknown
             * @param specified_height the height @paintable could be drawn into or   0.0 if unknown
             * @param default_width the width @paintable would be drawn into if   no other constraints were given
             * @param default_height the height @paintable would be drawn into if   no other constraints were given
             */
            compute_concrete_size(
                specified_width: number,
                specified_height: number,
                default_width: number,
                default_height: number,
            ): [number, number];
            /**
             * Gets an immutable paintable for the current contents displayed by `paintable`.
             *
             * This is useful when you want to retain the current state of an animation,
             * for example to take a screenshot of a running animation.
             *
             * If the `paintable` is already immutable, it will return itself.
             * @returns An immutable paintable for the current   contents of @paintable
             */
            get_current_image(): Gdk.Paintable;
            /**
             * Get flags for the paintable.
             *
             * This is oftentimes useful for optimizations.
             *
             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
             * @returns The `GdkPaintableFlags` for this paintable
             */
            get_flags(): Gdk.PaintableFlags;
            /**
             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
             *
             * The aspect ratio is the width divided by the height, so a value of 0.5
             * means that the `paintable` prefers to be displayed twice as high as it
             * is wide. Consumers of this interface can use this to preserve aspect
             * ratio when displaying the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * Usually when a `paintable` returns nonzero values from
             * [method`Gdk`.Paintable.get_intrinsic_width] and
             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
             * should conform to those values, though that is not required.
             *
             * If the `paintable` does not have a preferred aspect ratio,
             * it returns 0. Negative values are never returned.
             * @returns the intrinsic aspect ratio of @paintable or 0 if none.
             */
            get_intrinsic_aspect_ratio(): number;
            /**
             * Gets the preferred height the `paintable` would like to be displayed at.
             *
             * Consumers of this interface can use this to reserve enough space to draw
             * the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * If the `paintable` does not have a preferred height, it returns 0.
             * Negative values are never returned.
             * @returns the intrinsic height of @paintable or 0 if none.
             */
            get_intrinsic_height(): number;
            /**
             * Gets the preferred width the `paintable` would like to be displayed at.
             *
             * Consumers of this interface can use this to reserve enough space to draw
             * the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * If the `paintable` does not have a preferred width, it returns 0.
             * Negative values are never returned.
             * @returns the intrinsic width of @paintable or 0 if none.
             */
            get_intrinsic_width(): number;
            /**
             * Called by implementations of `GdkPaintable` to invalidate their contents.
             *
             * Unless the contents are invalidated, implementations must guarantee that
             * multiple calls of [method`Gdk`.Paintable.snapshot] produce the same output.
             *
             * This function will emit the [signal`Gdk`.Paintable::invalidate-contents]
             * signal.
             *
             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_CONTENTS flag,
             * it must not call this function.
             */
            invalidate_contents(): void;
            /**
             * Called by implementations of `GdkPaintable` to invalidate their size.
             *
             * As long as the size is not invalidated, `paintable` must return the same
             * values for its intrinsic width, height and aspect ratio.
             *
             * This function will emit the [signal`Gdk`.Paintable::invalidate-size]
             * signal.
             *
             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_SIZE flag,
             * it must not call this function.
             */
            invalidate_size(): void;
            /**
             * Snapshots the given paintable with the given `width` and `height`.
             *
             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
             * If `width` and `height` are not larger than zero, this function will
             * do nothing.
             * @param snapshot a `GdkSnapshot` to snapshot to
             * @param width width to snapshot in
             * @param height height to snapshot in
             */
            snapshot(snapshot: Gdk.Snapshot, width: number, height: number): void;
            /**
             * Gets an immutable paintable for the current contents displayed by `paintable`.
             *
             * This is useful when you want to retain the current state of an animation,
             * for example to take a screenshot of a running animation.
             *
             * If the `paintable` is already immutable, it will return itself.
             */
            vfunc_get_current_image(): Gdk.Paintable;
            /**
             * Get flags for the paintable.
             *
             * This is oftentimes useful for optimizations.
             *
             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
             */
            vfunc_get_flags(): Gdk.PaintableFlags;
            /**
             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
             *
             * The aspect ratio is the width divided by the height, so a value of 0.5
             * means that the `paintable` prefers to be displayed twice as high as it
             * is wide. Consumers of this interface can use this to preserve aspect
             * ratio when displaying the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * Usually when a `paintable` returns nonzero values from
             * [method`Gdk`.Paintable.get_intrinsic_width] and
             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
             * should conform to those values, though that is not required.
             *
             * If the `paintable` does not have a preferred aspect ratio,
             * it returns 0. Negative values are never returned.
             */
            vfunc_get_intrinsic_aspect_ratio(): number;
            /**
             * Gets the preferred height the `paintable` would like to be displayed at.
             *
             * Consumers of this interface can use this to reserve enough space to draw
             * the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * If the `paintable` does not have a preferred height, it returns 0.
             * Negative values are never returned.
             */
            vfunc_get_intrinsic_height(): number;
            /**
             * Gets the preferred width the `paintable` would like to be displayed at.
             *
             * Consumers of this interface can use this to reserve enough space to draw
             * the paintable.
             *
             * This is a purely informational value and does not in any way limit the
             * values that may be passed to [method`Gdk`.Paintable.snapshot].
             *
             * If the `paintable` does not have a preferred width, it returns 0.
             * Negative values are never returned.
             */
            vfunc_get_intrinsic_width(): number;
            /**
             * Snapshots the given paintable with the given `width` and `height`.
             *
             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
             * If `width` and `height` are not larger than zero, this function will
             * do nothing.
             * @param snapshot a `GdkSnapshot` to snapshot to
             * @param width width to snapshot in
             * @param height height to snapshot in
             */
            vfunc_snapshot(snapshot: Gdk.Snapshot, width: number, height: number): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Window {
            // Signal callback interfaces

            interface ActivateDefault {
                (): void;
            }

            interface ActivateFocus {
                (): void;
            }

            interface CloseRequest {
                (): boolean;
            }

            interface EnableDebugging {
                (toggle: boolean): boolean;
            }

            interface KeysChanged {
                (): void;
            }

            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps,
                    Native.ConstructorProps,
                    Root.ConstructorProps,
                    ShortcutManager.ConstructorProps {
                application: Application;
                child: Widget;
                decorated: boolean;
                default_height: number;
                defaultHeight: number;
                default_widget: Widget;
                defaultWidget: Widget;
                default_width: number;
                defaultWidth: number;
                deletable: boolean;
                destroy_with_parent: boolean;
                destroyWithParent: boolean;
                display: Gdk.Display;
                focus_visible: boolean;
                focusVisible: boolean;
                focus_widget: Widget;
                focusWidget: Widget;
                fullscreened: boolean;
                handle_menubar_accel: boolean;
                handleMenubarAccel: boolean;
                hide_on_close: boolean;
                hideOnClose: boolean;
                icon_name: string;
                iconName: string;
                is_active: boolean;
                isActive: boolean;
                maximized: boolean;
                mnemonics_visible: boolean;
                mnemonicsVisible: boolean;
                modal: boolean;
                resizable: boolean;
                startup_id: string;
                startupId: string;
                suspended: boolean;
                title: string;
                titlebar: Widget;
                transient_for: Window;
                transientFor: Window;
            }
        }

        /**
         * A `GtkWindow` is a toplevel window which can contain other widgets.
         *
         * ![An example GtkWindow](window.png)
         *
         * Windows normally have decorations that are under the control
         * of the windowing system and allow the user to manipulate the window
         * (resize it, move it, close it,...).
         *
         * # GtkWindow as GtkBuildable
         *
         * The `GtkWindow` implementation of the [iface`Gtk`.Buildable] interface supports
         * setting a child as the titlebar by specifying “titlebar” as the “type”
         * attribute of a `<child>` element.
         *
         * # Shortcuts and Gestures
         *
         * `GtkWindow` supports the following keyboard shortcuts:
         *
         * - <kbd>F10</kbd> activates the menubar, if present.
         * - <kbd>Alt</kbd> makes the mnemonics visible while pressed.
         *
         * The following signals have default keybindings:
         *
         * - [signal`Gtk`.Window::activate-default]
         * - [signal`Gtk`.Window::activate-focus]
         * - [signal`Gtk`.Window::enable-debugging]
         *
         * # Actions
         *
         * `GtkWindow` defines a set of built-in actions:
         *
         * - `default.activate` activates the default widget.
         * - `window.minimize` minimizes the window.
         * - `window.toggle-maximized` maximizes or restores the window.
         * - `window.close` closes the window.
         *
         * # CSS nodes
         *
         * ```
         * window.background [.csd / .solid-csd / .ssd] [.maximized / .fullscreen / .tiled]
         * ├── <child>
         * ╰── <titlebar child>.titlebar [.default-decoration]
         * ```
         *
         * `GtkWindow` has a main CSS node with name window and style class .background.
         *
         * Style classes that are typically used with the main CSS node are .csd (when
         * client-side decorations are in use), .solid-csd (for client-side decorations
         * without invisible borders), .ssd (used by mutter when rendering server-side
         * decorations). GtkWindow also represents window states with the following
         * style classes on the main node: .maximized, .fullscreen, .tiled (when supported,
         * also .tiled-top, .tiled-left, .tiled-right, .tiled-bottom).
         *
         * `GtkWindow` subclasses often add their own discriminating style classes,
         * such as .dialog, .popup or .tooltip.
         *
         * Generally, some CSS properties don't make sense on the toplevel window node,
         * such as margins or padding. When client-side decorations without invisible
         * borders are in use (i.e. the .solid-csd style class is added to the
         * main window node), the CSS border of the toplevel window is used for
         * resize drags. In the .csd case, the shadow area outside of the window
         * can be used to resize it.
         *
         * `GtkWindow` adds the .titlebar and .default-decoration style classes to the
         * widget that is added as a titlebar child.
         *
         * # Accessibility
         *
         * Until GTK 4.10, `GtkWindow` used the `GTK_ACCESSIBLE_ROLE_WINDOW` role.
         *
         * Since GTK 4.12, `GtkWindow` uses the `GTK_ACCESSIBLE_ROLE_APPLICATION` role.
         */
        class Window extends Widget implements Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager {
            static $gtype: GObject.GType<Window>;

            // Properties

            /**
             * The `GtkApplication` associated with the window.
             *
             * The application will be kept alive for at least as long as it
             * has any windows associated with it (see g_application_hold()
             * for a way to keep it alive without windows).
             *
             * Normally, the connection between the application and the window
             * will remain until the window is destroyed, but you can explicitly
             * remove it by setting the :application property to %NULL.
             */
            get application(): Application;
            set application(val: Application);
            /**
             * The child widget.
             */
            get child(): Widget;
            set child(val: Widget);
            /**
             * Whether the window should have a frame (also known as *decorations*).
             */
            get decorated(): boolean;
            set decorated(val: boolean);
            /**
             * The default height of the window.
             */
            get default_height(): number;
            set default_height(val: number);
            /**
             * The default height of the window.
             */
            get defaultHeight(): number;
            set defaultHeight(val: number);
            /**
             * The default widget.
             */
            get default_widget(): Widget;
            set default_widget(val: Widget);
            /**
             * The default widget.
             */
            get defaultWidget(): Widget;
            set defaultWidget(val: Widget);
            /**
             * The default width of the window.
             */
            get default_width(): number;
            set default_width(val: number);
            /**
             * The default width of the window.
             */
            get defaultWidth(): number;
            set defaultWidth(val: number);
            /**
             * Whether the window frame should have a close button.
             */
            get deletable(): boolean;
            set deletable(val: boolean);
            /**
             * If this window should be destroyed when the parent is destroyed.
             */
            get destroy_with_parent(): boolean;
            set destroy_with_parent(val: boolean);
            /**
             * If this window should be destroyed when the parent is destroyed.
             */
            get destroyWithParent(): boolean;
            set destroyWithParent(val: boolean);
            /**
             * The display that will display this window.
             */
            get display(): Gdk.Display;
            set display(val: Gdk.Display);
            /**
             * Whether 'focus rectangles' are currently visible in this window.
             *
             * This property is maintained by GTK based on user input
             * and should not be set by applications.
             */
            get focus_visible(): boolean;
            set focus_visible(val: boolean);
            /**
             * Whether 'focus rectangles' are currently visible in this window.
             *
             * This property is maintained by GTK based on user input
             * and should not be set by applications.
             */
            get focusVisible(): boolean;
            set focusVisible(val: boolean);
            /**
             * The focus widget.
             */
            get focus_widget(): Widget;
            set focus_widget(val: Widget);
            /**
             * The focus widget.
             */
            get focusWidget(): Widget;
            set focusWidget(val: Widget);
            /**
             * Whether the window is fullscreen.
             *
             * Setting this property is the equivalent of calling
             * [method`Gtk`.Window.fullscreen] or [method`Gtk`.Window.unfullscreen];
             * either operation is asynchronous, which means you will need to
             * connect to the ::notify signal in order to know whether the
             * operation was successful.
             */
            get fullscreened(): boolean;
            set fullscreened(val: boolean);
            /**
             * Whether the window frame should handle F10 for activating
             * menubars.
             */
            get handle_menubar_accel(): boolean;
            set handle_menubar_accel(val: boolean);
            /**
             * Whether the window frame should handle F10 for activating
             * menubars.
             */
            get handleMenubarAccel(): boolean;
            set handleMenubarAccel(val: boolean);
            /**
             * If this window should be hidden when the users clicks the close button.
             */
            get hide_on_close(): boolean;
            set hide_on_close(val: boolean);
            /**
             * If this window should be hidden when the users clicks the close button.
             */
            get hideOnClose(): boolean;
            set hideOnClose(val: boolean);
            /**
             * Specifies the name of the themed icon to use as the window icon.
             *
             * See [class`Gtk`.IconTheme] for more details.
             */
            get icon_name(): string;
            set icon_name(val: string);
            /**
             * Specifies the name of the themed icon to use as the window icon.
             *
             * See [class`Gtk`.IconTheme] for more details.
             */
            get iconName(): string;
            set iconName(val: string);
            /**
             * Whether the toplevel is the currently active window.
             */
            get is_active(): boolean;
            /**
             * Whether the toplevel is the currently active window.
             */
            get isActive(): boolean;
            /**
             * Whether the window is maximized.
             *
             * Setting this property is the equivalent of calling
             * [method`Gtk`.Window.maximize] or [method`Gtk`.Window.unmaximize];
             * either operation is asynchronous, which means you will need to
             * connect to the ::notify signal in order to know whether the
             * operation was successful.
             */
            get maximized(): boolean;
            set maximized(val: boolean);
            /**
             * Whether mnemonics are currently visible in this window.
             *
             * This property is maintained by GTK based on user input,
             * and should not be set by applications.
             */
            get mnemonics_visible(): boolean;
            set mnemonics_visible(val: boolean);
            /**
             * Whether mnemonics are currently visible in this window.
             *
             * This property is maintained by GTK based on user input,
             * and should not be set by applications.
             */
            get mnemonicsVisible(): boolean;
            set mnemonicsVisible(val: boolean);
            /**
             * If %TRUE, the window is modal.
             */
            get modal(): boolean;
            set modal(val: boolean);
            /**
             * If %TRUE, users can resize the window.
             */
            get resizable(): boolean;
            set resizable(val: boolean);
            /**
             * A write-only property for setting window's startup notification identifier.
             */
            set startup_id(val: string);
            /**
             * A write-only property for setting window's startup notification identifier.
             */
            set startupId(val: string);
            /**
             * Whether the window is suspended.
             *
             * See [method`Gtk`.Window.is_suspended] for details about what suspended means.
             */
            get suspended(): boolean;
            /**
             * The title of the window.
             */
            get title(): string;
            set title(val: string);
            /**
             * The titlebar widget.
             */
            get titlebar(): Widget;
            set titlebar(val: Widget);
            /**
             * The transient parent of the window.
             */
            get transient_for(): Window;
            set transient_for(val: Window);
            /**
             * The transient parent of the window.
             */
            get transientFor(): Window;
            set transientFor(val: Window);

            // Constructors

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

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

            static ['new'](): Window;

            // Signals

            connect(id: string, callback: (...args: any[]) => any): number;
            connect_after(id: string, callback: (...args: any[]) => any): number;
            emit(id: string, ...args: any[]): void;
            connect(signal: 'activate-default', callback: (_source: this) => void): number;
            connect_after(signal: 'activate-default', callback: (_source: this) => void): number;
            emit(signal: 'activate-default'): void;
            connect(signal: 'activate-focus', callback: (_source: this) => void): number;
            connect_after(signal: 'activate-focus', callback: (_source: this) => void): number;
            emit(signal: 'activate-focus'): void;
            connect(signal: 'close-request', callback: (_source: this) => boolean): number;
            connect_after(signal: 'close-request', callback: (_source: this) => boolean): number;
            emit(signal: 'close-request'): void;
            connect(signal: 'enable-debugging', callback: (_source: this, toggle: boolean) => boolean): number;
            connect_after(signal: 'enable-debugging', callback: (_source: this, toggle: boolean) => boolean): number;
            emit(signal: 'enable-debugging', toggle: boolean): void;
            connect(signal: 'keys-changed', callback: (_source: this) => void): number;
            connect_after(signal: 'keys-changed', callback: (_source: this) => void): number;
            emit(signal: 'keys-changed'): void;

            // Static methods

            /**
             * Returns the fallback icon name for windows.
             *
             * The returned string is owned by GTK and should not
             * be modified. It is only valid until the next call to
             * [func`Gtk`.Window.set_default_icon_name].
             */
            static get_default_icon_name(): string | null;
            /**
             * Returns a list of all existing toplevel windows.
             *
             * If you want to iterate through the list and perform actions involving
             * callbacks that might destroy the widgets or add new ones, be aware that
             * the list of toplevels will change and emit the "items-changed" signal.
             */
            static get_toplevels(): Gio.ListModel;
            /**
             * Returns a list of all existing toplevel windows.
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you must
             * call `g_list_foreach (result, (GFunc)g_object_ref, NULL)` first,
             * and then unref all the widgets afterwards.
             */
            static list_toplevels(): Widget[];
            /**
             * Sets whether the window should request startup notification.
             *
             * By default, after showing the first `GtkWindow`, GTK calls
             * [method`Gdk`.Toplevel.set_startup_id]. Call this function
             * to disable the automatic startup notification. You might do this
             * if your first window is a splash screen, and you want to delay
             * notification until after your real main window has been shown,
             * for example.
             *
             * In that example, you would disable startup notification
             * temporarily, show your splash screen, then re-enable it so that
             * showing the main window would automatically result in notification.
             * @param setting %TRUE to automatically do startup notification
             */
            static set_auto_startup_notification(setting: boolean): void;
            /**
             * Sets an icon to be used as fallback.
             *
             * The fallback icon is used for windows that
             * haven't had [method`Gtk`.Window.set_icon_name]
             * called on them.
             * @param name the name of the themed icon
             */
            static set_default_icon_name(name: string): void;
            /**
             * Opens or closes the [interactive debugger](running.html#interactive-debugging).
             *
             * The debugger offers access to the widget hierarchy of the application
             * and to useful debugging tools.
             *
             * This function allows applications that already use
             * <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>I</kbd>
             * (or <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>D</kbd>)
             * for their own key shortcuts to add a different shortcut to open the Inspector.
             *
             * If you are not overriding the default key shortcuts for the Inspector,
             * you should not use this function.
             * @param enable %TRUE to enable interactive debugging
             */
            static set_interactive_debugging(enable: boolean): void;

            // Virtual methods

            /**
             * Activates the default widget for the window.
             */
            vfunc_activate_default(): void;
            /**
             * Activates the current focused widget within the window.
             */
            vfunc_activate_focus(): void;
            /**
             * Class handler for the `GtkWindow::close-request` signal.
             */
            vfunc_close_request(): boolean;
            /**
             * Class handler for the `GtkWindow::enable-debugging`
             *   keybinding signal.
             * @param toggle
             */
            vfunc_enable_debugging(toggle: boolean): boolean;
            /**
             * Signal gets emitted when the set of accelerators or
             *   mnemonics that are associated with window changes.
             */
            vfunc_keys_changed(): void;

            // Methods

            /**
             * Requests that the window is closed.
             *
             * This is similar to what happens when a window manager
             * close button is clicked.
             *
             * This function can be used with close buttons in custom
             * titlebars.
             */
            close(): void;
            /**
             * Drop the internal reference GTK holds on toplevel windows.
             */
            destroy(): void;
            /**
             * Asks to place `window` in the fullscreen state.
             *
             * Note that you shouldn’t assume the window is definitely fullscreen
             * afterward, because other entities (e.g. the user or window manager)
             * unfullscreen it again, and not all window managers honor requests
             * to fullscreen windows.
             *
             * You can track the result of this operation via the
             * [property`Gdk`.Toplevel:state] property, or by listening to
             * notifications of the [property`Gtk`.Window:fullscreened] property.
             */
            fullscreen(): void;
            /**
             * Asks to place `window` in the fullscreen state on the given `monitor`.
             *
             * Note that you shouldn't assume the window is definitely fullscreen
             * afterward, or that the windowing system allows fullscreen windows on
             * any given monitor.
             *
             * You can track the result of this operation via the
             * [property`Gdk`.Toplevel:state] property, or by listening to
             * notifications of the [property`Gtk`.Window:fullscreened] property.
             * @param monitor which monitor to go fullscreen on
             */
            fullscreen_on_monitor(monitor: Gdk.Monitor): void;
            /**
             * Gets the `GtkApplication` associated with the window.
             * @returns a `GtkApplication`
             */
            get_application(): Application | null;
            /**
             * Gets the child widget of `window`.
             * @returns the child widget of @window
             */
            get_child(): Widget | null;
            /**
             * Returns whether the window has been set to have decorations.
             * @returns %TRUE if the window has been set to have decorations
             */
            get_decorated(): boolean;
            /**
             * Gets the default size of the window.
             *
             * A value of 0 for the width or height indicates that a default
             * size has not been explicitly set for that dimension, so the
             * “natural” size of the window will be used.
             *
             * This function is the recommended way for [saving window state
             * across restarts of applications](https://developer.gnome.org/documentation/tutorials/save-state.html).
             */
            get_default_size(): [number, number];
            /**
             * Returns the default widget for `window`.
             * @returns the default widget
             */
            get_default_widget(): Widget | null;
            /**
             * Returns whether the window has been set to have a close button.
             * @returns %TRUE if the window has been set to have a close button
             */
            get_deletable(): boolean;
            /**
             * Returns whether the window will be destroyed with its transient parent.
             * @returns %TRUE if the window will be destroyed with its transient parent.
             */
            get_destroy_with_parent(): boolean;
            /**
             * Retrieves the current focused widget within the window.
             *
             * Note that this is the widget that would have the focus
             * if the toplevel window focused; if the toplevel window
             * is not focused then `gtk_widget_has_focus (widget)` will
             * not be %TRUE for the widget.
             * @returns the currently focused widget
             */
            get_focus(): Widget | null;
            /**
             * Gets whether “focus rectangles” are supposed to be visible.
             * @returns %TRUE if “focus rectangles” are supposed to be visible   in this window.
             */
            get_focus_visible(): boolean;
            /**
             * Returns the group for `window`.
             *
             * If the window has no group, then the default group is returned.
             * @returns the `GtkWindowGroup` for a window   or the default group
             */
            get_group(): WindowGroup;
            /**
             * Returns whether this window reacts to F10 key presses by
             * activating a menubar it contains.
             * @returns %TRUE if the window handles F10
             */
            get_handle_menubar_accel(): boolean;
            /**
             * Returns whether the window will be hidden when the close button is clicked.
             * @returns %TRUE if the window will be hidden
             */
            get_hide_on_close(): boolean;
            /**
             * Returns the name of the themed icon for the window.
             * @returns the icon name
             */
            get_icon_name(): string | null;
            /**
             * Gets whether mnemonics are supposed to be visible.
             * @returns %TRUE if mnemonics are supposed to be visible   in this window.
             */
            get_mnemonics_visible(): boolean;
            /**
             * Returns whether the window is modal.
             * @returns %TRUE if the window is set to be modal and   establishes a grab when shown
             */
            get_modal(): boolean;
            /**
             * Gets the value set by gtk_window_set_resizable().
             * @returns %TRUE if the user can resize the window
             */
            get_resizable(): boolean;
            /**
             * Retrieves the title of the window.
             * @returns the title of the window
             */
            get_title(): string | null;
            /**
             * Returns the custom titlebar that has been set with
             * gtk_window_set_titlebar().
             * @returns the custom titlebar
             */
            get_titlebar(): Widget | null;
            /**
             * Fetches the transient parent for this window.
             * @returns the transient parent for this window
             */
            get_transient_for(): Window | null;
            /**
             * Returns whether `window` has an explicit window group.
             * @returns %TRUE if @window has an explicit window group.
             */
            has_group(): boolean;
            /**
             * Retrieves the current fullscreen state of `window`.
             *
             * Note that since fullscreening is ultimately handled by the window
             * manager and happens asynchronously to an application request, you
             * shouldn’t assume the return value of this function changing
             * immediately (or at all), as an effect of calling
             * [method`Gtk`.Window.fullscreen] or [method`Gtk`.Window.unfullscreen].
             *
             * If the window isn't yet mapped, the value returned will whether the
             * initial requested state is fullscreen.
             * @returns whether the window has a fullscreen state.
             */
            is_fullscreen(): boolean;
            /**
             * Retrieves the current maximized state of `window`.
             *
             * Note that since maximization is ultimately handled by the window
             * manager and happens asynchronously to an application request, you
             * shouldn’t assume the return value of this function changing
             * immediately (or at all), as an effect of calling
             * [method`Gtk`.Window.maximize] or [method`Gtk`.Window.unmaximize].
             *
             * If the window isn't yet mapped, the value returned will whether the
             * initial requested state is maximized.
             * @returns whether the window has a maximized state.
             */
            is_maximized(): boolean;
            /**
             * Retrieves the current suspended state of `window`.
             *
             * A window being suspended means it's currently not visible to the user, for
             * example by being on a inactive workspace, minimized, obstructed.
             * @returns whether the window is suspended.
             */
            is_suspended(): boolean;
            /**
             * Asks to maximize `window,` so that it fills the screen.
             *
             * Note that you shouldn’t assume the window is definitely maximized
             * afterward, because other entities (e.g. the user or window manager)
             * could unmaximize it again, and not all window managers support
             * maximization.
             *
             * It’s permitted to call this function before showing a window,
             * in which case the window will be maximized when it appears onscreen
             * initially.
             *
             * You can track the result of this operation via the
             * [property`Gdk`.Toplevel:state] property, or by listening to
             * notifications on the [property`Gtk`.Window:maximized]
             * property.
             */
            maximize(): void;
            /**
             * Asks to minimize the specified `window`.
             *
             * Note that you shouldn’t assume the window is definitely minimized
             * afterward, because the windowing system might not support this
             * functionality; other entities (e.g. the user or the window manager)
             * could unminimize it again, or there may not be a window manager in
             * which case minimization isn’t possible, etc.
             *
             * It’s permitted to call this function before showing a window,
             * in which case the window will be minimized before it ever appears
             * onscreen.
             *
             * You can track result of this operation via the
             * [property`Gdk`.Toplevel:state] property.
             */
            minimize(): void;
            /**
             * Presents a window to the user.
             *
             * This may mean raising the window in the stacking order,
             * unminimizing it, moving it to the current desktop and/or
             * giving it the keyboard focus (possibly dependent on the user’s
             * platform, window manager and preferences).
             *
             * If `window` is hidden, this function also makes it visible.
             */
            present(): void;
            /**
             * Presents a window to the user in response to an user interaction.
             *
             * See [method`Gtk`.Window.present] for more details.
             *
             * The timestamp should be gathered when the window was requested
             * to be shown (when clicking a link for example), rather than once
             * the window is ready to be shown.
             * @param timestamp the timestamp of the user interaction (typically a   button or key press event) which triggered this call
             */
            present_with_time(timestamp: number): void;
            /**
             * Sets or unsets the `GtkApplication` associated with the window.
             *
             * The application will be kept alive for at least as long as it has
             * any windows associated with it (see g_application_hold() for a way
             * to keep it alive without windows).
             *
             * Normally, the connection between the application and the window will
             * remain until the window is destroyed, but you can explicitly remove
             * it by setting the `application` to %NULL.
             *
             * This is equivalent to calling [method`Gtk`.Application.remove_window]
             * and/or [method`Gtk`.Application.add_window] on the old/new applications
             * as relevant.
             * @param application a `GtkApplication`, or %NULL to unset
             */
            set_application(application?: Application | null): void;
            /**
             * Sets the child widget of `window`.
             * @param child the child widget
             */
            set_child(child?: Widget | null): void;
            /**
             * Sets whether the window should be decorated.
             *
             * By default, windows are decorated with a title bar, resize
             * controls, etc. Some window managers allow GTK to disable these
             * decorations, creating a borderless window. If you set the decorated
             * property to %FALSE using this function, GTK will do its best to
             * convince the window manager not to decorate the window. Depending on
             * the system, this function may not have any effect when called on a
             * window that is already visible, so you should call it before calling
             * [method`Gtk`.Widget.show].
             *
             * On Windows, this function always works, since there’s no window manager
             * policy involved.
             * @param setting %TRUE to decorate the window
             */
            set_decorated(setting: boolean): void;
            /**
             * Sets the default size of a window.
             *
             * The default size of a window is the size that will be used if no other constraints apply.
             *
             * The default size will be updated whenever the window is resized
             * to reflect the new size, unless the window is forced to a size,
             * like when it is maximized or fullscreened.
             *
             * If the window’s minimum size request is larger than
             * the default, the default will be ignored.
             *
             * Setting the default size to a value <= 0 will cause it to be
             * ignored and the natural size request will be used instead. It
             * is possible to do this while the window is showing to "reset"
             * it to its initial size.
             *
             * Unlike [method`Gtk`.Widget.set_size_request], which sets a size
             * request for a widget and thus would keep users from shrinking
             * the window, this function only sets the initial size, just as
             * if the user had resized the window themselves. Users can still
             * shrink the window again as they normally would. Setting a default
             * size of -1 means to use the “natural” default size (the size request
             * of the window).
             *
             * If you use this function to reestablish a previously saved window size,
             * note that the appropriate size to save is the one returned by
             * [method`Gtk`.Window.get_default_size]. Using the window allocation
             * directly will not work in all circumstances and can lead to growing
             * or shrinking windows.
             * @param width width in pixels, or -1 to unset the default width
             * @param height height in pixels, or -1 to unset the default height
             */
            set_default_size(width: number, height: number): void;
            /**
             * Sets the default widget.
             *
             * The default widget is the widget that is activated when the user
             * presses Enter in a dialog (for example).
             * @param default_widget widget to be the default   to unset the default widget for the toplevel
             */
            set_default_widget(default_widget?: Widget | null): void;
            /**
             * Sets whether the window should be deletable.
             *
             * By default, windows have a close button in the window frame.
             * Some  window managers allow GTK to disable this button. If you
             * set the deletable property to %FALSE using this function, GTK
             * will do its best to convince the window manager not to show a
             * close button. Depending on the system, this function may not
             * have any effect when called on a window that is already visible,
             * so you should call it before calling [method`Gtk`.Widget.show].
             *
             * On Windows, this function always works, since there’s no window
             * manager policy involved.
             * @param setting %TRUE to decorate the window as deletable
             */
            set_deletable(setting: boolean): void;
            /**
             * If `setting` is %TRUE, then destroying the transient parent of `window`
             * will also destroy `window` itself.
             *
             * This is useful for dialogs that shouldn’t persist beyond the lifetime
             * of the main window they are associated with, for example.
             * @param setting whether to destroy @window with its transient parent
             */
            set_destroy_with_parent(setting: boolean): void;
            /**
             * Sets the `GdkDisplay` where the `window` is displayed.
             *
             * If the window is already mapped, it will be unmapped,
             * and then remapped on the new display.
             * @param display a `GdkDisplay`
             */
            set_display(display: Gdk.Display): void;
            /**
             * Sets the focus widget.
             *
             * If `focus` is not the current focus widget, and is focusable,
             * sets it as the focus widget for the window. If `focus` is %NULL,
             * unsets the focus widget for this window. To set the focus to a
             * particular widget in the toplevel, it is usually more convenient
             * to use [method`Gtk`.Widget.grab_focus] instead of this function.
             * @param focus widget to be the new focus widget, or %NULL to unset   any focus widget for the toplevel window.
             */
            set_focus(focus?: Widget | null): void;
            /**
             * Sets whether “focus rectangles” are supposed to be visible.
             *
             * This property is maintained by GTK based on user input,
             * and should not be set by applications.
             * @param setting the new value
             */
            set_focus_visible(setting: boolean): void;
            /**
             * Sets whether this window should react to F10 key presses
             * by activating a menubar it contains.
             * @param handle_menubar_accel %TRUE to make @window handle F10
             */
            set_handle_menubar_accel(handle_menubar_accel: boolean): void;
            /**
             * If `setting` is %TRUE, then clicking the close button on the window
             * will not destroy it, but only hide it.
             * @param setting whether to hide the window when it is closed
             */
            set_hide_on_close(setting: boolean): void;
            /**
             * Sets the icon for the window from a named themed icon.
             *
             * See the docs for [class`Gtk`.IconTheme] for more details.
             * On some platforms, the window icon is not used at all.
             *
             * Note that this has nothing to do with the WM_ICON_NAME
             * property which is mentioned in the ICCCM.
             * @param name the name of the themed icon
             */
            set_icon_name(name?: string | null): void;
            /**
             * Sets whether mnemonics are supposed to be visible.
             *
             * This property is maintained by GTK based on user input,
             * and should not be set by applications.
             * @param setting the new value
             */
            set_mnemonics_visible(setting: boolean): void;
            /**
             * Sets a window modal or non-modal.
             *
             * Modal windows prevent interaction with other windows in the same
             * application. To keep modal dialogs on top of main application windows,
             * use [method`Gtk`.Window.set_transient_for] to make the dialog transient
             * for the parent; most window managers will then disallow lowering the
             * dialog below the parent.
             * @param modal whether the window is modal
             */
            set_modal(modal: boolean): void;
            /**
             * Sets whether the user can resize a window.
             *
             * Windows are user resizable by default.
             * @param resizable %TRUE if the user can resize this window
             */
            set_resizable(resizable: boolean): void;
            /**
             * Sets the startup notification ID.
             *
             * Startup notification identifiers are used by desktop environment
             * to track application startup, to provide user feedback and other
             * features. This function changes the corresponding property on the
             * underlying `GdkSurface`.
             *
             * Normally, startup identifier is managed automatically and you should
             * only use this function in special cases like transferring focus from
             * other processes. You should use this function before calling
             * [method`Gtk`.Window.present] or any equivalent function generating
             * a window map event.
             *
             * This function is only useful on X11, not with other GTK targets.
             * @param startup_id a string with startup-notification identifier
             */
            set_startup_id(startup_id: string): void;
            /**
             * Sets the title of the `GtkWindow`.
             *
             * The title of a window will be displayed in its title bar; on the
             * X Window System, the title bar is rendered by the window manager
             * so exactly how the title appears to users may vary according to a
             * user’s exact configuration. The title should help a user distinguish
             * this window from other windows they may have open. A good title might
             * include the application name and current document filename, for example.
             *
             * Passing %NULL does the same as setting the title to an empty string.
             * @param title title of the window
             */
            set_title(title?: string | null): void;
            /**
             * Sets a custom titlebar for `window`.
             *
             * A typical widget used here is [class`Gtk`.HeaderBar], as it
             * provides various features expected of a titlebar while allowing
             * the addition of child widgets to it.
             *
             * If you set a custom titlebar, GTK will do its best to convince
             * the window manager not to put its own titlebar on the window.
             * Depending on the system, this function may not work for a window
             * that is already visible, so you set the titlebar before calling
             * [method`Gtk`.Widget.show].
             * @param titlebar the widget to use as titlebar
             */
            set_titlebar(titlebar?: Widget | null): void;
            /**
             * Dialog windows should be set transient for the main application
             * window they were spawned from. This allows window managers to e.g.
             * keep the dialog on top of the main window, or center the dialog
             * over the main window. [ctor`Gtk`.Dialog.new_with_buttons] and other
             * convenience functions in GTK will sometimes call
             * gtk_window_set_transient_for() on your behalf.
             *
             * Passing %NULL for `parent` unsets the current transient window.
             *
             * On Windows, this function puts the child window on top of the parent,
             * much as the window manager would have done on X.
             * @param parent parent window
             */
            set_transient_for(parent?: Window | null): void;
            /**
             * Asks to remove the fullscreen state for `window,` and return to
             * its previous state.
             *
             * Note that you shouldn’t assume the window is definitely not
             * fullscreen afterward, because other entities (e.g. the user or
             * window manager) could fullscreen it again, and not all window
             * managers honor requests to unfullscreen windows; normally the
             * window will end up restored to its normal state. Just don’t
             * write code that crashes if not.
             *
             * You can track the result of this operation via the
             * [property`Gdk`.Toplevel:state] property, or by listening to
             * notifications of the [property`Gtk`.Window:fullscreened] property.
             */
            unfullscreen(): void;
            /**
             * Asks to unmaximize `window`.
             *
             * Note that you shouldn’t assume the window is definitely unmaximized
             * afterward, because other entities (e.g. the user or window manager)
             * maximize it again, and not all window managers honor requests to
             * unmaximize.
             *
             * You can track the result of this operation via the
             * [property`Gdk`.Toplevel:state] property, or by listening to
             * notifications on the [property`Gtk`.Window:maximized] property.
             */
            unmaximize(): void;
            /**
             * Asks to unminimize the specified `window`.
             *
             * Note that you shouldn’t assume the window is definitely unminimized
             * afterward, because the windowing system might not support this
             * functionality; other entities (e.g. the user or the window manager)
             * could minimize it again, or there may not be a window manager in
             * which case minimization isn’t possible, etc.
             *
             * You can track result of this operation via the
             * [property`Gdk`.Toplevel:state] property.
             */
            unminimize(): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get can_focus(): boolean;
            set can_focus(val: boolean);
            /**
             * Whether the widget or any of its descendents can accept
             * the input focus.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get canFocus(): boolean;
            set canFocus(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get can_target(): boolean;
            set can_target(val: boolean);
            /**
             * Whether the widget can receive pointer events.
             */
            get canTarget(): boolean;
            set canTarget(val: boolean);
            /**
             * A list of css classes applied to this widget.
             */
            get css_classes(): string[];
            set css_classes(val: string[]);
            /**
             * A list of css classes applied to this widget.
             */
            get cssClasses(): string[];
            set cssClasses(val: string[]);
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get css_name(): string;
            /**
             * The name of this widget in the CSS tree.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get cssName(): string;
            /**
             * The cursor used by `widget`.
             */
            get cursor(): Gdk.Cursor;
            set cursor(val: Gdk.Cursor);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focus_on_click(): boolean;
            set focus_on_click(val: boolean);
            /**
             * Whether the widget should grab focus when it is clicked with the mouse.
             *
             * This property is only relevant for widgets that can take focus.
             */
            get focusOnClick(): boolean;
            set focusOnClick(val: boolean);
            /**
             * Whether this widget itself will accept the input focus.
             */
            get focusable(): boolean;
            set focusable(val: boolean);
            /**
             * How to distribute horizontal space if widget gets extra space.
             */
            get halign(): Align;
            set halign(val: Align);
            /**
             * Whether the widget is the default widget.
             */
            get has_default(): boolean;
            /**
             * Whether the widget is the default widget.
             */
            get hasDefault(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get has_focus(): boolean;
            /**
             * Whether the widget has the input focus.
             */
            get hasFocus(): boolean;
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get has_tooltip(): boolean;
            set has_tooltip(val: boolean);
            /**
             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
             *
             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
             * determine whether it will provide a tooltip or not.
             */
            get hasTooltip(): boolean;
            set hasTooltip(val: boolean);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get height_request(): number;
            set height_request(val: number);
            /**
             * Override for height request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get heightRequest(): number;
            set heightRequest(val: number);
            /**
             * Whether to expand horizontally.
             */
            get hexpand(): boolean;
            set hexpand(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpand_set(): boolean;
            set hexpand_set(val: boolean);
            /**
             * Whether to use the `hexpand` property.
             */
            get hexpandSet(): boolean;
            set hexpandSet(val: boolean);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layout_manager(): LayoutManager;
            set layout_manager(val: LayoutManager);
            /**
             * The `GtkLayoutManager` instance to use to compute the preferred size
             * of the widget, and allocate its children.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get layoutManager(): LayoutManager;
            set layoutManager(val: LayoutManager);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_bottom(): number;
            set margin_bottom(val: number);
            /**
             * Margin on bottom side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginBottom(): number;
            set marginBottom(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_end(): number;
            set margin_end(val: number);
            /**
             * Margin on end of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginEnd(): number;
            set marginEnd(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_start(): number;
            set margin_start(val: number);
            /**
             * Margin on start of widget, horizontally.
             *
             * This property supports left-to-right and right-to-left text
             * directions.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginStart(): number;
            set marginStart(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get margin_top(): number;
            set margin_top(val: number);
            /**
             * Margin on top side of widget.
             *
             * This property adds margin outside of the widget's normal size
             * request, the margin will be added in addition to the size from
             * [method`Gtk`.Widget.set_size_request] for example.
             */
            get marginTop(): number;
            set marginTop(val: number);
            /**
             * The name of the widget.
             */
            get name(): string;
            set name(val: string);
            /**
             * The requested opacity of the widget.
             */
            get opacity(): number;
            set opacity(val: number);
            /**
             * How content outside the widget's content area is treated.
             *
             * This property is meant to be set by widget implementations,
             * typically in their instance init function.
             */
            get overflow(): Overflow;
            set overflow(val: Overflow);
            /**
             * The parent widget of this widget.
             */
            get parent(): Widget;
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receives_default(): boolean;
            set receives_default(val: boolean);
            /**
             * Whether the widget will receive the default action when it is focused.
             */
            get receivesDefault(): boolean;
            set receivesDefault(val: boolean);
            /**
             * The `GtkRoot` widget of the widget tree containing this widget.
             *
             * This will be %NULL if the widget is not contained in a root widget.
             */
            get root(): Root;
            /**
             * The scale factor of the widget.
             */
            get scale_factor(): number;
            /**
             * The scale factor of the widget.
             */
            get scaleFactor(): number;
            /**
             * Whether the widget responds to input.
             */
            get sensitive(): boolean;
            set sensitive(val: boolean);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_markup(): string;
            set tooltip_markup(val: string);
            /**
             * Sets the text of tooltip to be the given string, which is marked up
             * with Pango markup.
             *
             * Also see [method`Gtk`.Tooltip.set_markup].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipMarkup(): string;
            set tooltipMarkup(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltip_text(): string;
            set tooltip_text(val: string);
            /**
             * Sets the text of tooltip to be the given string.
             *
             * Also see [method`Gtk`.Tooltip.set_text].
             *
             * This is a convenience property which will take care of getting the
             * tooltip shown if the given string is not %NULL:
             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
             * the default signal handler.
             *
             * Note that if both [property`Gtk`.Widget:tooltip-text] and
             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
             */
            get tooltipText(): string;
            set tooltipText(val: string);
            /**
             * How to distribute vertical space if widget gets extra space.
             */
            get valign(): Align;
            set valign(val: Align);
            /**
             * Whether to expand vertically.
             */
            get vexpand(): boolean;
            set vexpand(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpand_set(): boolean;
            set vexpand_set(val: boolean);
            /**
             * Whether to use the `vexpand` property.
             */
            get vexpandSet(): boolean;
            set vexpandSet(val: boolean);
            /**
             * Whether the widget is visible.
             */
            get visible(): boolean;
            set visible(val: boolean);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get width_request(): number;
            set width_request(val: number);
            /**
             * Override for width request of the widget.
             *
             * If this is -1, the natural request will be used.
             */
            get widthRequest(): number;
            set widthRequest(val: number);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Returns the renderer that is used for this `GtkNative`.
             * @returns the renderer for @self
             */
            get_renderer(): Gsk.Renderer | null;
            /**
             * Returns the surface of this `GtkNative`.
             * @returns the surface of @self
             */
            get_surface(): Gdk.Surface | null;
            /**
             * Retrieves the surface transform of `self`.
             *
             * This is the translation from `self'`s surface coordinates into
             * `self'`s widget coordinates.
             */
            get_surface_transform(): [number, number];
            /**
             * Realizes a `GtkNative`.
             *
             * This should only be used by subclasses.
             */
            realize(): void;
            /**
             * Unrealizes a `GtkNative`.
             *
             * This should only be used by subclasses.
             */
            unrealize(): void;
            /**
             * Returns the display that this `GtkRoot` is on.
             * @returns the display of @root
             */
            get_display(): Gdk.Display;
            /**
             * Add a `GtkShortcutController` to be managed.
             * @param controller
             */
            vfunc_add_controller(controller: ShortcutController): void;
            /**
             * Remove a `GtkShortcutController` that had previously
             *   been added
             * @param controller
             */
            vfunc_remove_controller(controller: ShortcutController): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
            /**
             * Enable or disable an action installed with
             * gtk_widget_class_install_action().
             * @param action_name action name, such as "clipboard.paste"
             * @param enabled whether the action is now enabled
             */
            action_set_enabled(action_name: string, enabled: boolean): void;
            /**
             * For widgets that can be “activated” (buttons, menu items, etc.),
             * this function activates them.
             *
             * The activation will emit the signal set using
             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
             *
             * Activation is what happens when you press <kbd>Enter</kbd>
             * on a widget during key navigation.
             *
             * If you wish to handle the activation keybinding yourself, it is
             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
             * created with [ctor`Gtk`.SignalAction.new].
             *
             * If `widget` isn't activatable, the function returns %FALSE.
             * @returns %TRUE if the widget was activatable
             */
            activate(): boolean;
            /**
             * Looks up the action in the action groups associated with
             * `widget` and its ancestors, and activates it.
             *
             * If the action is in an action group added with
             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
             * to be prefixed with the prefix that was used when the group was
             * inserted.
             *
             * The arguments must match the actions expected parameter type,
             * as returned by `g_action_get_parameter_type()`.
             * @param name the name of the action to activate
             * @param args parameters to use
             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
             */
            activate_action(name: string, args?: GLib.Variant | null): boolean;
            /**
             * Activates the `default.activate` action from `widget`.
             */
            activate_default(): void;
            /**
             * Adds `controller` to `widget` so that it will receive events.
             *
             * You will usually want to call this function right after
             * creating any kind of [class`Gtk`.EventController].
             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
             */
            add_controller(controller: EventController): void;
            /**
             * Adds a style class to `widget`.
             *
             * After calling this function, the widget’s style will match
             * for `css_class,` according to CSS matching rules.
             *
             * Use [method`Gtk`.Widget.remove_css_class] to remove the
             * style again.
             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
             */
            add_css_class(css_class: string): void;
            /**
             * Adds a widget to the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
             * list of mnemonic labels for the widget is cleared when the
             * widget is destroyed, so the caller must make sure to update
             * its internal state at this point as well.
             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
             */
            add_mnemonic_label(label: Widget): void;
            /**
             * Queues an animation frame update and adds a callback to be called
             * before each frame.
             *
             * Until the tick callback is removed, it will be called frequently
             * (usually at the frame rate of the output device or as quickly as
             * the application can be repainted, whichever is slower). For this
             * reason, is most suitable for handling graphics that change every
             * frame or every few frames. The tick callback does not automatically
             * imply a relayout or repaint. If you want a repaint or relayout, and
             * aren’t changing widget properties that would trigger that (for example,
             * changing the text of a `GtkLabel`), then you will have to call
             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
             * yourself.
             *
             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
             * for timing continuous animations and
             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
             * trying to display isolated frames at particular times.
             *
             * This is a more convenient alternative to connecting directly to the
             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
             * @param callback function   to call for updating animations
             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
             */
            add_tick_callback(callback: TickCallback): number;
            /**
             * This function is only used by `GtkWidget` subclasses, to
             * assign a size, position and (optionally) baseline to their
             * child widgets.
             *
             * In this function, the allocation and baseline may be adjusted.
             * The given allocation will be forced to be bigger than the
             * widget's minimum size, as well as at least 0×0 in size.
             *
             * For a version that does not take a transform, see
             * [method`Gtk`.Widget.size_allocate].
             * @param width New width of @widget
             * @param height New height of @widget
             * @param baseline New baseline of @widget, or -1
             * @param transform Transformation to be applied to @widget
             */
            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
            /**
             * Called by widgets as the user moves around the window using
             * keyboard shortcuts.
             *
             * The `direction` argument indicates what kind of motion is taking place (up,
             * down, left, right, tab forward, tab backward).
             *
             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
             * can override the virtual function in order to implement appropriate focus
             * behavior.
             *
             * The default `focus()` virtual function for a widget should return `TRUE` if
             * moving in `direction` left the focus on a focusable location inside that
             * widget, and `FALSE` if moving in `direction` moved the focus outside the
             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
             * to place the focus accordingly; when returning `FALSE`, they don’t modify
             * the current focus location.
             *
             * This function is used by custom widget implementations; if you're
             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
             * the focus to a particular widget.
             * @param direction direction of focus movement
             * @returns %TRUE if focus ended up inside @widget
             */
            child_focus(direction: DirectionType | null): boolean;
            /**
             * Computes the bounds for `widget` in the coordinate space of `target`.
             *
             * The bounds of widget are (the bounding box of) the region that it is
             * expected to draw in. See the [coordinate system](coordinates.html)
             * overview to learn more.
             *
             * If the operation is successful, %TRUE is returned. If `widget` has no
             * bounds or the bounds cannot be expressed in `target'`s coordinate space
             * (for example if both widgets are in different windows), %FALSE is
             * returned and `bounds` is set to the zero rectangle.
             *
             * It is valid for `widget` and `target` to be the same widget.
             * @param target the `GtkWidget`
             * @returns %TRUE if the bounds could be computed
             */
            compute_bounds(target: Widget): [boolean, Graphene.Rect];
            /**
             * Computes whether a container should give this widget
             * extra space when possible.
             *
             * Containers should check this, rather than looking at
             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
             *
             * This function already checks whether the widget is visible, so
             * visibility does not need to be checked separately. Non-visible
             * widgets are not expanded.
             *
             * The computed expand value uses either the expand setting explicitly
             * set on the widget itself, or, if none has been explicitly set,
             * the widget may expand if some of its children do.
             * @param orientation expand direction
             * @returns whether widget tree rooted here should be expanded
             */
            compute_expand(orientation: Orientation | null): boolean;
            /**
             * Translates the given `point` in `widget'`s coordinates to coordinates
             * relative to `target’`s coordinate system.
             *
             * In order to perform this operation, both widgets must share a
             * common ancestor.
             * @param target the `GtkWidget` to transform into
             * @param point a point in @widget's coordinate system
             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
             */
            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
            /**
             * Computes a matrix suitable to describe a transformation from
             * `widget'`s coordinate system into `target'`s coordinate system.
             *
             * The transform can not be computed in certain cases, for example
             * when `widget` and `target` do not share a common ancestor. In that
             * case `out_transform` gets set to the identity matrix.
             *
             * To learn more about widget coordinate systems, see the coordinate
             * system [overview](coordinates.html).
             * @param target the target widget that the matrix will transform to
             * @returns %TRUE if the transform could be computed, %FALSE otherwise
             */
            compute_transform(target: Widget): [boolean, Graphene.Matrix];
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @returns %TRUE if @widget contains (@x, @y).
             */
            contains(x: number, y: number): boolean;
            /**
             * Creates a new `PangoContext` with the appropriate font map,
             * font options, font description, and base direction for drawing
             * text for this widget.
             *
             * See also [method`Gtk`.Widget.get_pango_context].
             * @returns the new `PangoContext`
             */
            create_pango_context(): Pango.Context;
            /**
             * Creates a new `PangoLayout` with the appropriate font map,
             * font description, and base direction for drawing text for
             * this widget.
             *
             * If you keep a `PangoLayout` created in this way around,
             * you need to re-create it when the widget `PangoContext`
             * is replaced. This can be tracked by listening to changes
             * of the [property`Gtk`.Widget:root] property on the widget.
             * @param text text to set on the layout
             * @returns the new `PangoLayout`
             */
            create_pango_layout(text?: string | null): Pango.Layout;
            /**
             * Clears the template children for the given widget.
             *
             * This function is the opposite of [method`Gtk`.Widget.init_template], and
             * it is used to clear all the template children from a widget instance.
             * If you bound a template child to a field in the instance structure, or
             * in the instance private data structure, the field will be set to `NULL`
             * after this function returns.
             *
             * You should call this function inside the `GObjectClass.dispose()`
             * implementation of any widget that called `gtk_widget_init_template()`.
             * Typically, you will want to call this function last, right before
             * chaining up to the parent type's dispose implementation, e.g.
             *
             * ```c
             * static void
             * some_widget_dispose (GObject *gobject)
             * {
             *   SomeWidget *self = SOME_WIDGET (gobject);
             *
             *   // Clear the template data for SomeWidget
             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
             *
             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
             * }
             * ```
             * @param widget_type the type of the widget to finalize the template for
             */
            dispose_template(widget_type: GObject.GType): void;
            /**
             * Checks to see if a drag movement has passed the GTK drag threshold.
             * @param start_x X coordinate of start of drag
             * @param start_y Y coordinate of start of drag
             * @param current_x current X coordinate
             * @param current_y current Y coordinate
             * @returns %TRUE if the drag threshold has been passed.
             */
            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
            /**
             * Notifies the user about an input-related error on this widget.
             *
             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
             *
             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
             * in many ways, depending on the windowing backend and the desktop
             * environment or window manager that is used.
             */
            error_bell(): void;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_allocated_baseline(): number;
            /**
             * Returns the height that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the height of the @widget
             */
            get_allocated_height(): number;
            /**
             * Returns the width that has currently been allocated to `widget`.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns the width of the @widget
             */
            get_allocated_width(): number;
            /**
             * Retrieves the widget’s allocation.
             *
             * Note, when implementing a layout container: a widget’s allocation
             * will be its “adjusted” allocation, that is, the widget’s parent
             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
             * and that allocation is then adjusted (to handle margin
             * and alignment for example) before assignment to the widget.
             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
             * was actually assigned to the widget. The adjusted allocation is
             * guaranteed to be completely contained within the
             * [method`Gtk`.Widget.size_allocate] allocation, however.
             *
             * So a layout container is guaranteed that its children stay inside
             * the assigned bounds, but not that they have exactly the bounds the
             * container assigned.
             */
            get_allocation(): Allocation;
            /**
             * Gets the first ancestor of `widget` with type `widget_type`.
             *
             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
             * gets the first `GtkBox` that’s an ancestor of `widget`. No
             * reference will be added to the returned widget; it should
             * not be unreferenced.
             *
             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
             * considers `widget` to be an ancestor of itself.
             * @param widget_type ancestor type
             * @returns the ancestor widget
             */
            get_ancestor(widget_type: GObject.GType): Widget | null;
            /**
             * Returns the baseline that has currently been allocated to `widget`.
             *
             * This function is intended to be used when implementing handlers
             * for the `GtkWidget`Class.snapshot() function, and when allocating
             * child widgets in `GtkWidget`Class.size_allocate().
             * @returns the baseline of the @widget, or -1 if none
             */
            get_baseline(): number;
            /**
             * Determines whether the input focus can enter `widget` or any
             * of its children.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
             */
            get_can_focus(): boolean;
            /**
             * Queries whether `widget` can be the target of pointer events.
             * @returns %TRUE if @widget can receive pointer events
             */
            get_can_target(): boolean;
            /**
             * Gets the value set with gtk_widget_set_child_visible().
             *
             * If you feel a need to use this function, your code probably
             * needs reorganization.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @returns %TRUE if the widget is mapped with the parent.
             */
            get_child_visible(): boolean;
            /**
             * Gets the clipboard object for `widget`.
             *
             * This is a utility function to get the clipboard object for the
             * `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_clipboard(): Gdk.Clipboard;
            /**
             * Gets the current foreground color for the widget’s
             * CSS style.
             *
             * This function should only be used in snapshot
             * implementations that need to do custom
             * drawing with the foreground color.
             */
            get_color(): Gdk.RGBA;
            /**
             * Returns the list of style classes applied to `widget`.
             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
             */
            get_css_classes(): string[];
            /**
             * Returns the CSS name that is used for `self`.
             * @returns the CSS name
             */
            get_css_name(): string;
            /**
             * Queries the cursor set on `widget`.
             *
             * See [method`Gtk`.Widget.set_cursor] for details.
             * @returns the cursor   currently in use or %NULL if the cursor is inherited
             */
            get_cursor(): Gdk.Cursor | null;
            /**
             * Gets the reading direction for a particular widget.
             *
             * See [method`Gtk`.Widget.set_direction].
             * @returns the reading direction for the widget.
             */
            get_direction(): TextDirection;
            /**
             * Returns the widget’s first child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's first child
             */
            get_first_child(): Widget | null;
            /**
             * Returns the current focus child of `widget`.
             * @returns The current focus   child of @widget
             */
            get_focus_child(): Widget | null;
            /**
             * Returns whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * See [method`Gtk`.Widget.set_focus_on_click].
             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
             */
            get_focus_on_click(): boolean;
            /**
             * Determines whether `widget` can own the input focus.
             *
             * See [method`Gtk`.Widget.set_focusable].
             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
             */
            get_focusable(): boolean;
            /**
             * Gets the font map of `widget`.
             *
             * See [method`Gtk`.Widget.set_font_map].
             * @returns A `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * Returns the `cairo_font_options_t` of widget.
             *
             * Seee [method`Gtk`.Widget.set_font_options].
             * @returns the `cairo_font_options_t` of widget
             */
            get_font_options(): cairo.FontOptions | null;
            /**
             * Obtains the frame clock for a widget.
             *
             * The frame clock is a global “ticker” that can be used to drive
             * animations and repaints. The most common reason to get the frame
             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
             * to get a time to use for animating. For example you might record
             * the start of the animation with an initial value from
             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
             *
             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
             * clock, but won’t necessarily repaint any widgets. To repaint a
             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
             * the widget (thus scheduling it to receive a draw on the next
             * frame). gtk_widget_queue_draw() will also end up requesting a frame
             * on the appropriate frame clock.
             *
             * A widget’s frame clock will not change while the widget is
             * mapped. Reparenting a widget (which implies a temporary unmap) can
             * change the widget’s frame clock.
             *
             * Unrealized widgets do not have a frame clock.
             * @returns a `GdkFrameClock`
             */
            get_frame_clock(): Gdk.FrameClock | null;
            /**
             * Gets the horizontal alignment of `widget`.
             *
             * For backwards compatibility reasons this method will never return
             * one of the baseline alignments, but instead it will convert it to
             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
             *
             * Baselines are not supported for horizontal alignment.
             * @returns the horizontal alignment of @widget
             */
            get_halign(): Align;
            /**
             * Returns the current value of the `has-tooltip` property.
             * @returns current value of `has-tooltip` on @widget.
             */
            get_has_tooltip(): boolean;
            /**
             * Returns the content height of the widget.
             *
             * This function returns the height passed to its
             * size-allocate implementation, which is the height you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The height of @widget
             */
            get_height(): number;
            /**
             * Gets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Containers should use [method`Gtk`.Widget.compute_expand] rather
             * than this function, to see whether a widget, or any of its children,
             * has the expand flag set. If any child of a widget wants to
             * expand, the parent may ask to expand also.
             *
             * This function only looks at the widget’s own hexpand flag, rather
             * than computing whether the entire widget tree rooted at this widget
             * wants to expand.
             * @returns whether hexpand flag is set
             */
            get_hexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_hexpand() has been used
             * to explicitly set the expand flag on this widget.
             *
             * If [property`Gtk`.Widget:hexpand] property is set, then it
             * overrides any computed expand value based on child widgets.
             * If `hexpand` is not set, then the expand value depends on
             * whether any children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @returns whether hexpand has been explicitly set
             */
            get_hexpand_set(): boolean;
            /**
             * Returns the widget’s last child.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's last child
             */
            get_last_child(): Widget | null;
            /**
             * Retrieves the layout manager used by `widget`.
             *
             * See [method`Gtk`.Widget.set_layout_manager].
             * @returns a `GtkLayoutManager`
             */
            get_layout_manager(): LayoutManager | null;
            /**
             * Whether the widget is mapped.
             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
             */
            get_mapped(): boolean;
            /**
             * Gets the bottom margin of `widget`.
             * @returns The bottom margin of @widget
             */
            get_margin_bottom(): number;
            /**
             * Gets the end margin of `widget`.
             * @returns The end margin of @widget
             */
            get_margin_end(): number;
            /**
             * Gets the start margin of `widget`.
             * @returns The start margin of @widget
             */
            get_margin_start(): number;
            /**
             * Gets the top margin of `widget`.
             * @returns The top margin of @widget
             */
            get_margin_top(): number;
            /**
             * Retrieves the name of a widget.
             *
             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
             */
            get_name(): string;
            /**
             * Returns the nearest `GtkNative` ancestor of `widget`.
             *
             * This function will return %NULL if the widget is not
             * contained inside a widget tree with a native ancestor.
             *
             * `GtkNative` widgets will return themselves here.
             * @returns the `GtkNative` ancestor of @widget
             */
            get_native(): Native | null;
            /**
             * Returns the widget’s next sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's next sibling
             */
            get_next_sibling(): Widget | null;
            /**
             * #Fetches the requested opacity for this widget.
             *
             * See [method`Gtk`.Widget.set_opacity].
             * @returns the requested opacity for this widget.
             */
            get_opacity(): number;
            /**
             * Returns the widget’s overflow value.
             * @returns The widget's overflow.
             */
            get_overflow(): Overflow;
            /**
             * Gets a `PangoContext` with the appropriate font map, font description,
             * and base direction for this widget.
             *
             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
             * this context is owned by the widget (it can be used until the screen
             * for the widget changes or the widget is removed from its toplevel),
             * and will be updated to match any changes to the widget’s attributes.
             * This can be tracked by listening to changes of the
             * [property`Gtk`.Widget:root] property on the widget.
             * @returns the `PangoContext` for the widget.
             */
            get_pango_context(): Pango.Context;
            /**
             * Returns the parent widget of `widget`.
             * @returns the parent widget of @widget
             */
            get_parent(): Widget | null;
            /**
             * Retrieves the minimum and natural size of a widget, taking
             * into account the widget’s preference for height-for-width management.
             *
             * This is used to retrieve a suitable size by container widgets which do
             * not impose any restrictions on the child placement. It can be used
             * to deduce toplevel window and menu sizes as well as child widgets in
             * free-form containers such as `GtkFixed`.
             *
             * Handle with care. Note that the natural height of a height-for-width
             * widget will generally be a smaller size than the minimum height, since
             * the required height for the natural width is generally smaller than the
             * required height for the minimum width.
             *
             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
             */
            get_preferred_size(): [Requisition | null, Requisition | null];
            /**
             * Returns the widget’s previous sibling.
             *
             * This API is primarily meant for widget implementations.
             * @returns The widget's previous sibling
             */
            get_prev_sibling(): Widget | null;
            /**
             * Gets the primary clipboard of `widget`.
             *
             * This is a utility function to get the primary clipboard object
             * for the `GdkDisplay` that `widget` is using.
             *
             * Note that this function always works, even when `widget` is not
             * realized yet.
             * @returns the appropriate clipboard object
             */
            get_primary_clipboard(): Gdk.Clipboard;
            /**
             * Determines whether `widget` is realized.
             * @returns %TRUE if @widget is realized, %FALSE otherwise
             */
            get_realized(): boolean;
            /**
             * Determines whether `widget` is always treated as the default widget
             * within its toplevel when it has the focus, even if another widget
             * is the default.
             *
             * See [method`Gtk`.Widget.set_receives_default].
             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
             */
            get_receives_default(): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             * @returns The `GtkSizeRequestMode` preferred by @widget.
             */
            get_request_mode(): SizeRequestMode;
            /**
             * Returns the `GtkRoot` widget of `widget`.
             *
             * This function will return %NULL if the widget is not contained
             * inside a widget tree with a root widget.
             *
             * `GtkRoot` widgets will return themselves here.
             * @returns the root widget of @widget
             */
            get_root(): Root | null;
            /**
             * Retrieves the internal scale factor that maps from window
             * coordinates to the actual device pixels.
             *
             * On traditional systems this is 1, on high density outputs,
             * it can be a higher value (typically 2).
             *
             * See [method`Gdk`.Surface.get_scale_factor].
             * @returns the scale factor for @widget
             */
            get_scale_factor(): number;
            /**
             * Returns the widget’s sensitivity.
             *
             * This function returns the value that has been set using
             * [method`Gtk`.Widget.set_sensitive]).
             *
             * The effective sensitivity of a widget is however determined
             * by both its own and its parent widget’s sensitivity.
             * See [method`Gtk`.Widget.is_sensitive].
             * @returns %TRUE if the widget is sensitive
             */
            get_sensitive(): boolean;
            /**
             * Gets the settings object holding the settings used for this widget.
             *
             * Note that this function can only be called when the `GtkWidget`
             * is attached to a toplevel, since the settings object is specific
             * to a particular `GdkDisplay`. If you want to monitor the widget for
             * changes in its settings, connect to the `notify::display` signal.
             * @returns the relevant `GtkSettings` object
             */
            get_settings(): Settings;
            /**
             * Returns the content width or height of the widget.
             *
             * Which dimension is returned depends on `orientation`.
             *
             * This is equivalent to calling [method`Gtk`.Widget.get_width]
             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
             * for %GTK_ORIENTATION_VERTICAL, but can be used when
             * writing orientation-independent code, such as when
             * implementing [iface`Gtk`.Orientable] widgets.
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @param orientation the orientation to query
             * @returns The size of @widget in @orientation.
             */
            get_size(orientation: Orientation | null): number;
            /**
             * Gets the size request that was explicitly set for the widget using
             * gtk_widget_set_size_request().
             *
             * A value of -1 stored in `width` or `height` indicates that that
             * dimension has not been set explicitly and the natural requisition
             * of the widget will be used instead. See
             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
             * actually request, call [method`Gtk`.Widget.measure] instead of
             * this function.
             */
            get_size_request(): [number, number];
            /**
             * Returns the widget state as a flag set.
             *
             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
             * state will be returned, that is, also based on parent insensitivity,
             * even if `widget` itself is sensitive.
             *
             * Also note that if you are looking for a way to obtain the
             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
             * method, you should look at [method`Gtk`.StyleContext.get_state].
             * @returns The state flags for widget
             */
            get_state_flags(): StateFlags;
            /**
             * Returns the style context associated to `widget`.
             *
             * The returned object is guaranteed to be the same
             * for the lifetime of `widget`.
             * @returns the widget’s `GtkStyleContext`
             */
            get_style_context(): StyleContext;
            /**
             * Fetch an object build from the template XML for `widget_type` in
             * this `widget` instance.
             *
             * This will only report children which were previously declared
             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
             * variants.
             *
             * This function is only meant to be called for code which is private
             * to the `widget_type` which declared the child and is meant for language
             * bindings which cannot easily make use of the GObject structure offsets.
             * @param widget_type The `GType` to get a template child for
             * @param name The “id” of the child defined in the template XML
             * @returns The object built in the template XML with   the id @name
             */
            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the tooltip has not been set using
             * [method`Gtk`.Widget.set_tooltip_markup], this
             * function returns %NULL.
             * @returns the tooltip text
             */
            get_tooltip_markup(): string | null;
            /**
             * Gets the contents of the tooltip for `widget`.
             *
             * If the `widget'`s tooltip was set using
             * [method`Gtk`.Widget.set_tooltip_markup],
             * this function will return the escaped text.
             * @returns the tooltip text
             */
            get_tooltip_text(): string | null;
            /**
             * Gets the vertical alignment of `widget`.
             * @returns the vertical alignment of @widget
             */
            get_valign(): Align;
            /**
             * Gets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.get_hexpand] for more detail.
             * @returns whether vexpand flag is set
             */
            get_vexpand(): boolean;
            /**
             * Gets whether gtk_widget_set_vexpand() has been used to
             * explicitly set the expand flag on this widget.
             *
             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
             * @returns whether vexpand has been explicitly set
             */
            get_vexpand_set(): boolean;
            /**
             * Determines whether the widget is visible.
             *
             * If you want to take into account whether the widget’s
             * parent is also marked as visible, use
             * [method`Gtk`.Widget.is_visible] instead.
             *
             * This function does not check if the widget is
             * obscured in any way.
             *
             * See [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget is visible
             */
            get_visible(): boolean;
            /**
             * Returns the content width of the widget.
             *
             * This function returns the width passed to its
             * size-allocate implementation, which is the width you
             * should be using in [vfunc`Gtk`.Widget.snapshot].
             *
             * For pointer events, see [method`Gtk`.Widget.contains].
             *
             * To learn more about widget sizes, see the coordinate
             * system [overview](coordinates.html).
             * @returns The width of @widget
             */
            get_width(): number;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             * @returns %TRUE if focus is now inside @widget.
             */
            grab_focus(): boolean;
            /**
             * Returns whether `css_class` is currently applied to `widget`.
             * @param css_class A style class, without the leading '.'   used for notation of style classes
             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
             */
            has_css_class(css_class: string): boolean;
            /**
             * Determines if the widget should show a visible indication that
             * it has the global input focus.
             *
             * This is a convenience function that takes into account whether
             * focus indication should currently be shown in the toplevel window
             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
             * information about focus indication.
             *
             * To find out if the widget has the global input focus, use
             * [method`Gtk`.Widget.has_focus].
             * @returns %TRUE if the widget should display a “focus rectangle”
             */
            has_visible_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            hide(): void;
            /**
             * Returns whether the widget is currently being destroyed.
             *
             * This information can sometimes be used to avoid doing
             * unnecessary work.
             * @returns %TRUE if @widget is being destroyed
             */
            in_destruction(): boolean;
            /**
             * Creates and initializes child widgets defined in templates.
             *
             * This function must be called in the instance initializer
             * for any class which assigned itself a template using
             * [method`Gtk`.WidgetClass.set_template].
             *
             * It is important to call this function in the instance initializer
             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
             * `GObject.constructor()` for two reasons:
             *
             *  - derived widgets will assume that the composite widgets
             *    defined by its parent classes have been created in their
             *    relative instance initializers
             *  - when calling `g_object_new()` on a widget with composite templates,
             *    it’s important to build the composite widgets before the construct
             *    properties are set. Properties passed to `g_object_new()` should
             *    take precedence over properties set in the private template XML
             *
             * A good rule of thumb is to call this function as the first thing in
             * an instance initialization function.
             */
            init_template(): void;
            /**
             * Inserts `group` into `widget`.
             *
             * Children of `widget` that implement [iface`Gtk`.Actionable] can
             * then be associated with actions in `group` by setting their
             * “action-name” to `prefix`.`action-name`.
             *
             * Note that inheritance is defined for individual actions. I.e.
             * even if you insert a group with prefix `prefix,` actions with
             * the same prefix will still be inherited from the parent, unless
             * the group contains an action with the same name.
             *
             * If `group` is %NULL, a previously inserted group for `name` is
             * removed from `widget`.
             * @param name the prefix for actions in @group
             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
             */
            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed after `previous_sibling,` or at the beginning if
             * `previous_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
             * will return `previous_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this
             * function can also be used to reorder `widget` in the child widget
             * list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param previous_sibling the new previous sibling of @widget
             */
            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
            /**
             * Inserts `widget` into the child widget list of `parent`.
             *
             * It will be placed before `next_sibling,` or at the end if
             * `next_sibling` is %NULL.
             *
             * After calling this function, `gtk_widget_get_next_sibling(widget)`
             * will return `next_sibling`.
             *
             * If `parent` is already set as the parent widget of `widget,` this function
             * can also be used to reorder `widget` in the child widget list of `parent`.
             *
             * This API is primarily meant for widget implementations; if you are
             * just using a widget, you *must* use its own API for adding children.
             * @param parent the parent `GtkWidget` to insert @widget into
             * @param next_sibling the new next sibling of @widget
             */
            insert_before(parent: Widget, next_sibling?: Widget | null): void;
            /**
             * Determines whether `widget` is somewhere inside `ancestor,`
             * possibly with intermediate containers.
             * @param ancestor another `GtkWidget`
             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
             */
            is_ancestor(ancestor: Widget): boolean;
            /**
             * Determines whether `widget` can be drawn to.
             *
             * A widget can be drawn if it is mapped and visible.
             * @returns %TRUE if @widget is drawable, %FALSE otherwise
             */
            is_drawable(): boolean;
            /**
             * Determines if the widget is the focus widget within its
             * toplevel.
             *
             * This does not mean that the [property`Gtk`.Widget:has-focus]
             * property is necessarily set; [property`Gtk`.Widget:has-focus]
             * will only be set if the toplevel widget additionally has the
             * global input focus.
             * @returns %TRUE if the widget is the focus widget.
             */
            is_focus(): boolean;
            /**
             * Returns the widget’s effective sensitivity.
             *
             * This means it is sensitive itself and also its
             * parent widget is sensitive.
             * @returns %TRUE if the widget is effectively sensitive
             */
            is_sensitive(): boolean;
            /**
             * Determines whether the widget and all its parents are marked as
             * visible.
             *
             * This function does not check if the widget is obscured in any way.
             *
             * See also [method`Gtk`.Widget.get_visible] and
             * [method`Gtk`.Widget.set_visible].
             * @returns %TRUE if the widget and all its parents are visible
             */
            is_visible(): boolean;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
             */
            keynav_failed(direction: DirectionType | null): boolean;
            /**
             * Returns the widgets for which this widget is the target of a
             * mnemonic.
             *
             * Typically, these widgets will be labels. See, for example,
             * [method`Gtk`.Label.set_mnemonic_widget].
             *
             * The widgets in the list are not individually referenced.
             * If you want to iterate through the list and perform actions
             * involving callbacks that might destroy the widgets, you
             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
             * first, and then unref all the widgets afterwards.
             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
             */
            list_mnemonic_labels(): Widget[];
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             * @returns %TRUE if the signal has been handled
             */
            mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Returns a `GListModel` to track the children of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track children and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's children
             */
            observe_children(): Gio.ListModel;
            /**
             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
             * of `widget`.
             *
             * Calling this function will enable extra internal bookkeeping
             * to track controllers and emit signals on the returned listmodel.
             * It may slow down operations a lot.
             *
             * Applications should try hard to avoid calling this function
             * because of the slowdowns.
             * @returns a `GListModel` tracking @widget's controllers
             */
            observe_controllers(): Gio.ListModel;
            /**
             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
             *
             * The point must be given in widget coordinates, so (0, 0) is assumed
             * to be the top left of `widget'`s content area.
             *
             * Usually widgets will return %NULL if the given coordinate is not
             * contained in `widget` checked via [method`Gtk`.Widget.contains].
             * Otherwise they will recursively try to find a child that does
             * not return %NULL. Widgets are however free to customize their
             * picking algorithm.
             *
             * This function is used on the toplevel to determine the widget
             * below the mouse cursor for purposes of hover highlighting and
             * delivering events.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             * @param flags Flags to influence what is picked
             * @returns The widget descendant at   the given point
             */
            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
            /**
             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
             * function.
             *
             * Use this function instead of [method`Gtk`.Widget.queue_resize]
             * when the `widget'`s size request didn't change but it wants to
             * reposition its contents.
             *
             * An example user of this function is [method`Gtk`.Widget.set_halign].
             *
             * This function is only for use in widget implementations.
             */
            queue_allocate(): void;
            /**
             * Schedules this widget to be redrawn in the paint phase
             * of the current or the next frame.
             *
             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
             * implementation will be called.
             */
            queue_draw(): void;
            /**
             * Flags a widget to have its size renegotiated.
             *
             * This should be called when a widget for some reason has a new
             * size request. For example, when you change the text in a
             * [class`Gtk`.Label], the label queues a resize to ensure there’s
             * enough space for the new text.
             *
             * Note that you cannot call gtk_widget_queue_resize() on a widget
             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
             * virtual method. Calls to gtk_widget_queue_resize() from inside
             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
             *
             * This function is only for use in widget implementations.
             */
            queue_resize(): void;
            /**
             * Removes `controller` from `widget,` so that it doesn't process
             * events anymore.
             *
             * It should not be used again.
             *
             * Widgets will remove all event controllers automatically when they
             * are destroyed, there is normally no need to call this function.
             * @param controller a `GtkEventController`
             */
            remove_controller(controller: EventController): void;
            /**
             * Removes a style from `widget`.
             *
             * After this, the style of `widget` will stop matching for `css_class`.
             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
             */
            remove_css_class(css_class: string): void;
            /**
             * Removes a widget from the list of mnemonic labels for this widget.
             *
             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
             * have previously been added to the list with
             * [method`Gtk`.Widget.add_mnemonic_label].
             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
             */
            remove_mnemonic_label(label: Widget): void;
            /**
             * Removes a tick callback previously registered with
             * gtk_widget_add_tick_callback().
             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
             */
            remove_tick_callback(id: number): void;
            /**
             * Specifies whether the input focus can enter the widget
             * or any of its children.
             *
             * Applications should set `can_focus` to %FALSE to mark a
             * widget as for pointer/touch use only.
             *
             * Note that having `can_focus` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and focusable and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param can_focus whether or not the input focus can enter   the widget or any of its children
             */
            set_can_focus(can_focus: boolean): void;
            /**
             * Sets whether `widget` can be the target of pointer events.
             * @param can_target whether this widget should be able to   receive pointer events
             */
            set_can_target(can_target: boolean): void;
            /**
             * Sets whether `widget` should be mapped along with its parent.
             *
             * The child visibility can be set for widget before it is added
             * to a container with [method`Gtk`.Widget.set_parent], to avoid
             * mapping children unnecessary before immediately unmapping them.
             * However it will be reset to its default state of %TRUE when the
             * widget is removed from a container.
             *
             * Note that changing the child visibility of a widget does not
             * queue a resize on the widget. Most of the time, the size of
             * a widget is computed from all visible children, whether or
             * not they are mapped. If this is not the case, the container
             * can queue a resize itself.
             *
             * This function is only useful for container implementations
             * and should never be called by an application.
             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
             */
            set_child_visible(child_visible: boolean): void;
            /**
             * Clear all style classes applied to `widget`
             * and replace them with `classes`.
             * @param classes %NULL-terminated list of style classes to apply to @widget.
             */
            set_css_classes(classes: string[]): void;
            /**
             * Sets the cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * If the `cursor` is NULL, `widget` will use the cursor
             * inherited from the parent widget.
             * @param cursor the new cursor
             */
            set_cursor(cursor?: Gdk.Cursor | null): void;
            /**
             * Sets a named cursor to be shown when pointer devices point
             * towards `widget`.
             *
             * This is a utility function that creates a cursor via
             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
             * with [method`Gtk`.Widget.set_cursor]. See those functions for
             * details.
             *
             * On top of that, this function allows `name` to be %NULL, which
             * will do the same as calling [method`Gtk`.Widget.set_cursor]
             * with a %NULL cursor.
             * @param name The name of the cursor
             */
            set_cursor_from_name(name?: string | null): void;
            /**
             * Sets the reading direction on a particular widget.
             *
             * This direction controls the primary direction for widgets
             * containing text, and also the direction in which the children
             * of a container are packed. The ability to set the direction is
             * present in order so that correct localization into languages with
             * right-to-left reading directions can be done. Generally, applications
             * will let the default reading direction present, except for containers
             * where the containers are arranged in an order that is explicitly
             * visual rather than logical (such as buttons for text justification).
             *
             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
             * set by [func`Gtk`.Widget.set_default_direction] will be used.
             * @param dir the new direction
             */
            set_direction(dir: TextDirection | null): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            set_focus_child(child?: Widget | null): void;
            /**
             * Sets whether the widget should grab focus when it is clicked
             * with the mouse.
             *
             * Making mouse clicks not grab focus is useful in places like
             * toolbars where you don’t want the keyboard focus removed from
             * the main area of the application.
             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
             */
            set_focus_on_click(focus_on_click: boolean): void;
            /**
             * Specifies whether `widget` can own the input focus.
             *
             * Widget implementations should set `focusable` to %TRUE in
             * their init() function if they want to receive keyboard input.
             *
             * Note that having `focusable` be %TRUE is only one of the
             * necessary conditions for being focusable. A widget must
             * also be sensitive and can-focus and not have an ancestor
             * that is marked as not can-focus in order to receive input
             * focus.
             *
             * See [method`Gtk`.Widget.grab_focus] for actually setting
             * the input focus on a widget.
             * @param focusable whether or not @widget can own the input focus
             */
            set_focusable(focusable: boolean): void;
            /**
             * Sets the font map to use for Pango rendering.
             *
             * The font map is the object that is used to look up fonts.
             * Setting a custom font map can be useful in special situations,
             * e.g. when you need to add application-specific fonts to the set
             * of available fonts.
             *
             * When not set, the widget will inherit the font map from its parent.
             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
             */
            set_font_map(font_map?: Pango.FontMap | null): void;
            /**
             * Sets the `cairo_font_options_t` used for Pango rendering
             * in this widget.
             *
             * When not set, the default font options for the `GdkDisplay`
             * will be used.
             * @param options a `cairo_font_options_t`   to unset any previously set default font options
             */
            set_font_options(options?: cairo.FontOptions | null): void;
            /**
             * Sets the horizontal alignment of `widget`.
             * @param align the horizontal alignment
             */
            set_halign(align: Align | null): void;
            /**
             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
             * @param has_tooltip whether or not @widget has a tooltip.
             */
            set_has_tooltip(has_tooltip: boolean): void;
            /**
             * Sets whether the widget would like any available extra horizontal
             * space.
             *
             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
             * generally receive the extra space. For example, a list or
             * scrollable area or document in your window would often be set to
             * expand.
             *
             * Call this function to set the expand flag if you would like your
             * widget to become larger horizontally when the window has extra
             * room.
             *
             * By default, widgets automatically expand if any of their children
             * want to expand. (To see if a widget will automatically expand given
             * its current children and state, call [method`Gtk`.Widget.compute_expand].
             * A container can decide how the expandability of children affects the
             * expansion of the container by overriding the compute_expand virtual
             * method on `GtkWidget`.).
             *
             * Setting hexpand explicitly with this function will override the
             * automatic expand behavior.
             *
             * This function forces the widget to expand or not to expand,
             * regardless of children.  The override occurs because
             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
             * value to be used, rather than looking at children and widget state.
             * @param expand whether to expand
             */
            set_hexpand(expand: boolean): void;
            /**
             * Sets whether the hexpand flag will be used.
             *
             * The [property`Gtk`.Widget:hexpand-set] property will be set
             * automatically when you call [method`Gtk`.Widget.set_hexpand]
             * to set hexpand, so the most likely reason to use this function
             * would be to unset an explicit expand flag.
             *
             * If hexpand is set, then it overrides any computed
             * expand value based on child widgets. If hexpand is not
             * set, then the expand value depends on whether any
             * children of the widget would like to expand.
             *
             * There are few reasons to use this function, but it’s here
             * for completeness and consistency.
             * @param set value for hexpand-set property
             */
            set_hexpand_set(set: boolean): void;
            /**
             * Sets the layout manager delegate instance that provides an
             * implementation for measuring and allocating the children of `widget`.
             * @param layout_manager a `GtkLayoutManager`
             */
            set_layout_manager(layout_manager?: LayoutManager | null): void;
            /**
             * Sets the bottom margin of `widget`.
             * @param margin the bottom margin
             */
            set_margin_bottom(margin: number): void;
            /**
             * Sets the end margin of `widget`.
             * @param margin the end margin
             */
            set_margin_end(margin: number): void;
            /**
             * Sets the start margin of `widget`.
             * @param margin the start margin
             */
            set_margin_start(margin: number): void;
            /**
             * Sets the top margin of `widget`.
             * @param margin the top margin
             */
            set_margin_top(margin: number): void;
            /**
             * Sets a widgets name.
             *
             * Setting a name allows you to refer to the widget from a
             * CSS file. You can apply a style to widgets with a particular name
             * in the CSS file. See the documentation for the CSS syntax (on the
             * same page as the docs for [class`Gtk`.StyleContext].
             *
             * Note that the CSS syntax has certain special characters to delimit
             * and represent elements in a selector (period, #, >, *...), so using
             * these will make your widget impossible to match by name. Any combination
             * of alphanumeric symbols, dashes and underscores will suffice.
             * @param name name for the widget
             */
            set_name(name: string): void;
            /**
             * Request the `widget` to be rendered partially transparent.
             *
             * An opacity of 0 is fully transparent and an opacity of 1
             * is fully opaque.
             *
             * Opacity works on both toplevel widgets and child widgets, although
             * there are some limitations: For toplevel widgets, applying opacity
             * depends on the capabilities of the windowing system. On X11, this
             * has any effect only on X displays with a compositing manager,
             * see gdk_display_is_composited(). On Windows and Wayland it should
             * always work, although setting a window’s opacity after the window
             * has been shown may cause some flicker.
             *
             * Note that the opacity is inherited through inclusion — if you set
             * a toplevel to be partially translucent, all of its content will
             * appear translucent, since it is ultimatively rendered on that
             * toplevel. The opacity value itself is not inherited by child
             * widgets (since that would make widgets deeper in the hierarchy
             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
             * and other [iface`Gtk`.Native] widgets with their own surface will use their
             * own opacity value, and thus by default appear non-translucent,
             * even if they are attached to a toplevel that is translucent.
             * @param opacity desired opacity, between 0 and 1
             */
            set_opacity(opacity: number): void;
            /**
             * Sets how `widget` treats content that is drawn outside the
             * widget's content area.
             *
             * See the definition of [enum`Gtk`.Overflow] for details.
             *
             * This setting is provided for widget implementations and
             * should not be used by application code.
             *
             * The default value is %GTK_OVERFLOW_VISIBLE.
             * @param overflow desired overflow
             */
            set_overflow(overflow: Overflow | null): void;
            /**
             * Sets `parent` as the parent widget of `widget`.
             *
             * This takes care of details such as updating the state and style
             * of the child to reflect its new location and resizing the parent.
             * The opposite function is [method`Gtk`.Widget.unparent].
             *
             * This function is useful only when implementing subclasses of
             * `GtkWidget`.
             * @param parent parent widget
             */
            set_parent(parent: Widget): void;
            /**
             * Specifies whether `widget` will be treated as the default
             * widget within its toplevel when it has the focus, even if
             * another widget is the default.
             * @param receives_default whether or not @widget can be a default widget.
             */
            set_receives_default(receives_default: boolean): void;
            /**
             * Sets the sensitivity of a widget.
             *
             * A widget is sensitive if the user can interact with it.
             * Insensitive widgets are “grayed out” and the user can’t
             * interact with them. Insensitive widgets are known as
             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
             * @param sensitive %TRUE to make the widget sensitive
             */
            set_sensitive(sensitive: boolean): void;
            /**
             * Sets the minimum size of a widget.
             *
             * That is, the widget’s size request will be at least `width`
             * by `height`. You can use this function to force a widget to
             * be larger than it normally would be.
             *
             * In most cases, [method`Gtk`.Window.set_default_size] is a better
             * choice for toplevel windows than this function; setting the default
             * size will still allow users to shrink the window. Setting the size
             * request will force them to leave the window at least as large as
             * the size request.
             *
             * Note the inherent danger of setting any fixed size - themes,
             * translations into other languages, different fonts, and user action
             * can all change the appropriate size for a given widget. So, it's
             * basically impossible to hardcode a size that will always be
             * correct.
             *
             * The size request of a widget is the smallest size a widget can
             * accept while still functioning well and drawing itself correctly.
             * However in some strange cases a widget may be allocated less than
             * its requested size, and in many cases a widget may be allocated more
             * space than it requested.
             *
             * If the size request in a given direction is -1 (unset), then
             * the “natural” size request of the widget will be used instead.
             *
             * The size request set here does not include any margin from the
             * properties
             * [property`Gtk`.Widget:margin-start],
             * [property`Gtk`.Widget:margin-end],
             * [property`Gtk`.Widget:margin-top], and
             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
             * much all other padding or border properties set by any subclass
             * of `GtkWidget`.
             * @param width width @widget should request, or -1 to unset
             * @param height height @widget should request, or -1 to unset
             */
            set_size_request(width: number, height: number): void;
            /**
             * Turns on flag values in the current widget state.
             *
             * Typical widget states are insensitive, prelighted, etc.
             *
             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
             * the widget's direction, use [method`Gtk`.Widget.set_direction].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn on
             * @param clear Whether to clear state before turning on @flags
             */
            set_state_flags(flags: StateFlags | null, clear: boolean): void;
            /**
             * Sets `markup` as the contents of the tooltip, which is marked
             * up with Pango markup.
             *
             * This function will take care of setting the
             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_markup].
             * @param markup the contents of the tooltip for @widget
             */
            set_tooltip_markup(markup?: string | null): void;
            /**
             * Sets `text` as the contents of the tooltip.
             *
             * If `text` contains any markup, it will be escaped.
             *
             * This function will take care of setting
             * [property`Gtk`.Widget:has-tooltip] as a side effect,
             * and of the default handler for the
             * [signal`Gtk`.Widget::query-tooltip] signal.
             *
             * See also [method`Gtk`.Tooltip.set_text].
             * @param text the contents of the tooltip for @widget
             */
            set_tooltip_text(text?: string | null): void;
            /**
             * Sets the vertical alignment of `widget`.
             * @param align the vertical alignment
             */
            set_valign(align: Align | null): void;
            /**
             * Sets whether the widget would like any available extra vertical
             * space.
             *
             * See [method`Gtk`.Widget.set_hexpand] for more detail.
             * @param expand whether to expand
             */
            set_vexpand(expand: boolean): void;
            /**
             * Sets whether the vexpand flag will be used.
             *
             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
             * @param set value for vexpand-set property
             */
            set_vexpand_set(set: boolean): void;
            /**
             * Sets the visibility state of `widget`.
             *
             * Note that setting this to %TRUE doesn’t mean the widget is
             * actually viewable, see [method`Gtk`.Widget.get_visible].
             * @param visible whether the widget should be shown or not
             */
            set_visible(visible: boolean): void;
            /**
             * Returns whether `widget` should contribute to
             * the measuring and allocation of its parent.
             *
             * This is %FALSE for invisible children, but also
             * for children that have their own surface.
             * @returns %TRUE if child should be included in   measuring and allocating
             */
            should_layout(): boolean;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            show(): void;
            /**
             * Allocates widget with a transformation that translates
             * the origin to the position in `allocation`.
             *
             * This is a simple form of [method`Gtk`.Widget.allocate].
             * @param allocation position and size to be allocated to @widget
             * @param baseline The baseline of the child, or -1
             */
            size_allocate(allocation: Allocation, baseline: number): void;
            /**
             * Snapshot the a child of `widget`.
             *
             * When a widget receives a call to the snapshot function,
             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
             * to all children. This function provides a convenient way
             * of doing this. A widget, when it receives a call to its
             * [vfunc`Gtk`.Widget.snapshot] function, calls
             * gtk_widget_snapshot_child() once for each child, passing in
             * the `snapshot` the widget received.
             *
             * gtk_widget_snapshot_child() takes care of translating the origin of
             * `snapshot,` and deciding whether the child needs to be snapshot.
             *
             * This function does nothing for children that implement `GtkNative`.
             * @param child a child of @widget
             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
             */
            snapshot_child(child: Widget, snapshot: Snapshot): void;
            /**
             * Translate coordinates relative to `src_widget’`s allocation
             * to coordinates relative to `dest_widget’`s allocations.
             *
             * In order to perform this operation, both widget must share
             * a common ancestor.
             * @param dest_widget a `GtkWidget`
             * @param src_x X position relative to @src_widget
             * @param src_y Y position relative to @src_widget
             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
             */
            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
            /**
             * Triggers a tooltip query on the display where the toplevel
             * of `widget` is located.
             */
            trigger_tooltip_query(): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            unmap(): void;
            /**
             * Dissociate `widget` from its parent.
             *
             * This function is only for use in widget implementations,
             * typically in dispose.
             */
            unparent(): void;
            /**
             * Turns off flag values for the current widget state.
             *
             * See [method`Gtk`.Widget.set_state_flags].
             *
             * This function is for use in widget implementations.
             * @param flags State flags to turn off
             */
            unset_state_flags(flags: StateFlags | null): void;
            /**
             * Computes whether a container should give this
             *   widget extra space when possible.
             * @param hexpand_p
             * @param vexpand_p
             */
            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
            /**
             * Tests if the point at (`x,` `y)` is contained in `widget`.
             *
             * The coordinates for (`x,` `y)` must be in widget coordinates, so
             * (0, 0) is assumed to be the top left of `widget'`s content area.
             * @param x X coordinate to test, relative to @widget's origin
             * @param y Y coordinate to test, relative to @widget's origin
             */
            vfunc_contains(x: number, y: number): boolean;
            /**
             * Vfunc called when the CSS used by widget was changed. Widgets
             *   should then discard their caches that depend on CSS and queue resizes or
             *   redraws accordingly. The default implementation will take care of this for
             *   all the default CSS properties, so implementations must chain up.
             * @param change
             */
            vfunc_css_changed(change: CssStyleChange): void;
            /**
             * Signal emitted when the text direction of a
             *   widget changes.
             * @param previous_direction
             */
            vfunc_direction_changed(previous_direction: TextDirection): void;
            /**
             * Vfunc for gtk_widget_child_focus()
             * @param direction
             */
            vfunc_focus(direction: DirectionType): boolean;
            /**
             * Gets whether the widget prefers a height-for-width layout
             * or a width-for-height layout.
             *
             * Single-child widgets generally propagate the preference of
             * their child, more complex widgets need to request something
             * either in context of their children or in context of their
             * allocation capabilities.
             */
            vfunc_get_request_mode(): SizeRequestMode;
            /**
             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
             *
             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
             * implementation cannot transfer the focus to a descendant of `widget`
             * that is focusable, it will not take focus and %FALSE will be returned.
             *
             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
             * is allowed, should not have an effect, and return %TRUE.
             */
            vfunc_grab_focus(): boolean;
            /**
             * Reverses the effects of gtk_widget_show().
             *
             * This is causing the widget to be hidden (invisible to the user).
             */
            vfunc_hide(): void;
            /**
             * Emits the `::keynav-failed` signal on the widget.
             *
             * This function should be called whenever keyboard navigation
             * within a single widget hits a boundary.
             *
             * The return value of this function should be interpreted
             * in a way similar to the return value of
             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
             * stay in the widget, the failed keyboard  navigation is OK
             * and/or there is nowhere we can/should move the focus to.
             * When %FALSE is returned, the caller should continue with
             * keyboard navigation outside the widget, e.g. by calling
             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
             *
             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
             * For the other values of `GtkDirectionType` it returns %TRUE.
             *
             * Whenever the default handler returns %TRUE, it also calls
             * [method`Gtk`.Widget.error_bell] to notify the user of the
             * failed keyboard navigation.
             *
             * A use case for providing an own implementation of ::keynav-failed
             * (either by connecting to it or by overriding it) would be a row of
             * [class`Gtk`.Entry] widgets where the user should be able to navigate
             * the entire row with the cursor keys, as e.g. known from user
             * interfaces that require entering license keys.
             * @param direction direction of focus movement
             */
            vfunc_keynav_failed(direction: DirectionType): boolean;
            /**
             * Causes a widget to be mapped if it isn’t already.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_map(): void;
            /**
             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
             *
             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
             * is 300, this functions will compute the minimum and natural width of `widget`
             * if it is allocated at a height of 300 pixels.
             *
             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
             * a more details on implementing `GtkWidgetClass.measure()`.
             * @param orientation the orientation to measure
             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
             */
            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
            /**
             * Emits the ::mnemonic-activate signal.
             *
             * See [signal`Gtk`.Widget::mnemonic-activate].
             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
             */
            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
            /**
             * Signal emitted when a change of focus is requested
             * @param direction
             */
            vfunc_move_focus(direction: DirectionType): void;
            /**
             * Signal emitted when “has-tooltip” is %TRUE and the
             *   hover timeout has expired with the cursor hovering “above”
             *   widget; or emitted when widget got focus in keyboard mode.
             * @param x
             * @param y
             * @param keyboard_tooltip
             * @param tooltip
             */
            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
            /**
             * Creates the GDK resources associated with a widget.
             *
             * Normally realization happens implicitly; if you show a widget
             * and all its parent containers, then the widget will be realized
             * and mapped automatically.
             *
             * Realizing a widget requires all the widget’s parent widgets to be
             * realized; calling this function realizes the widget’s parents
             * in addition to `widget` itself. If a widget is not yet inside a
             * toplevel window when you realize it, bad things will happen.
             *
             * This function is primarily used in widget implementations, and
             * isn’t very useful otherwise. Many times when you think you might
             * need it, a better approach is to connect to a signal that will be
             * called after the widget is realized automatically, such as
             * [signal`Gtk`.Widget::realize].
             */
            vfunc_realize(): void;
            /**
             * Called when the widget gets added to a `GtkRoot` widget. Must
             *   chain up
             */
            vfunc_root(): void;
            /**
             * Set `child` as the current focus child of `widget`.
             *
             * This function is only suitable for widget implementations.
             * If you want a certain widget to get the input focus, call
             * [method`Gtk`.Widget.grab_focus] on it.
             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
             */
            vfunc_set_focus_child(child?: Widget | null): void;
            /**
             * Flags a widget to be displayed.
             *
             * Any widget that isn’t shown will not appear on the screen.
             *
             * Remember that you have to show the containers containing a widget,
             * in addition to the widget itself, before it will appear onscreen.
             *
             * When a toplevel container is shown, it is immediately realized and
             * mapped; other shown widgets are realized and mapped when their
             * toplevel container is realized and mapped.
             */
            vfunc_show(): void;
            /**
             * Called to set the allocation, if the widget does
             *   not have a layout manager.
             * @param width
             * @param height
             * @param baseline
             */
            vfunc_size_allocate(width: number, height: number, baseline: number): void;
            /**
             * Vfunc called when a new snapshot of the widget has to be taken.
             * @param snapshot
             */
            vfunc_snapshot(snapshot: Snapshot): void;
            /**
             * Signal emitted when the widget state changes,
             *   see gtk_widget_get_state_flags().
             * @param previous_state_flags
             */
            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
            /**
             * Emitted when a system setting was changed. Must chain up.
             * @param settings
             */
            vfunc_system_setting_changed(settings: SystemSetting): void;
            /**
             * Causes a widget to be unmapped if it’s currently mapped.
             *
             * This function is only for use in widget implementations.
             */
            vfunc_unmap(): void;
            /**
             * Causes a widget to be unrealized (frees all GDK resources
             * associated with the widget).
             *
             * This function is only useful in widget implementations.
             */
            vfunc_unrealize(): void;
            /**
             * Called when the widget is about to be removed from its
             *   `GtkRoot` widget. Must chain up
             */
            vfunc_unroot(): void;
        }

        namespace WindowControls {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                decoration_layout: string;
                decorationLayout: string;
                empty: boolean;
                side: PackType;
            }
        }

        /**
         * `GtkWindowControls` shows window frame controls.
         *
         * Typical window frame controls are minimize, maximize and close buttons,
         * and the window icon.
         *
         * ![An example GtkWindowControls](windowcontrols.png)
         *
         * `GtkWindowControls` only displays start or end side of the controls (see
         * [property`Gtk`.WindowControls:side]), so it's intended to be always used
         * in pair with another `GtkWindowControls` for the opposite side, for example:
         *
         * ```xml
         * <object class="GtkBox">
         *   <child>
         *     <object class="GtkWindowControls">
         *       <property name="side">start</property>
         *     </object>
         *   </child>
         *
         *   ...
         *
         *   <child>
         *     <object class="GtkWindowControls">
         *       <property name="side">end</property>
         *     </object>
         *   </child>
         * </object>
         * ```
         *
         * # CSS nodes
         *
         * ```
         * windowcontrols
         * ├── [image.icon]
         * ├── [button.minimize]
         * ├── [button.maximize]
         * ╰── [button.close]
         * ```
         *
         * A `GtkWindowControls`' CSS node is called windowcontrols. It contains
         * subnodes corresponding to each title button. Which of the title buttons
         * exist and where they are placed exactly depends on the desktop environment
         * and [property`Gtk`.WindowControls:decoration-layout] value.
         *
         * When [property`Gtk`.WindowControls:empty] is %TRUE, it gets the .empty
         * style class.
         *
         * # Accessibility
         *
         * `GtkWindowControls` uses the %GTK_ACCESSIBLE_ROLE_GROUP role.
         */
        class WindowControls extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<WindowControls>;

            // Properties

            /**
             * The decoration layout for window buttons.
             *
             * If this property is not set, the
             * [property`Gtk`.Settings:gtk-decoration-layout] setting is used.
             */
            get decoration_layout(): string;
            set decoration_layout(val: string);
            /**
             * The decoration layout for window buttons.
             *
             * If this property is not set, the
             * [property`Gtk`.Settings:gtk-decoration-layout] setting is used.
             */
            get decorationLayout(): string;
            set decorationLayout(val: string);
            /**
             * Whether the widget has any window buttons.
             */
            get empty(): boolean;
            /**
             * Whether the widget shows start or end side of the decoration layout.
             *
             * See [property`Gtk`.WindowControls:decoration_layout].
             */
            get side(): PackType;
            set side(val: PackType);

            // Constructors

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

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

            static ['new'](side: PackType): WindowControls;

            // Methods

            /**
             * Gets the decoration layout of this `GtkWindowControls`.
             * @returns the decoration layout or %NULL if it is unset
             */
            get_decoration_layout(): string | null;
            /**
             * Gets whether the widget has any window buttons.
             * @returns %TRUE if the widget has window buttons, otherwise %FALSE
             */
            get_empty(): boolean;
            /**
             * Gets the side to which this `GtkWindowControls` instance belongs.
             * @returns the side
             */
            get_side(): PackType;
            /**
             * Sets the decoration layout for the title buttons.
             *
             * This overrides the [property`Gtk`.Settings:gtk-decoration-layout]
             * setting.
             *
             * The format of the string is button names, separated by commas.
             * A colon separates the buttons that should appear on the left
             * from those on the right. Recognized button names are minimize,
             * maximize, close and icon (the window icon).
             *
             * For example, “icon:minimize,maximize,close” specifies a icon
             * on the left, and minimize, maximize and close buttons on the right.
             *
             * If [property`Gtk`.WindowControls:side] value is `GTK_PACK_START,` `self`
             * will display the part before the colon, otherwise after that.
             * @param layout a decoration layout, or %NULL to unset the layout
             */
            set_decoration_layout(layout?: string | null): void;
            /**
             * Determines which part of decoration layout the `GtkWindowControls` uses.
             *
             * See [property`Gtk`.WindowControls:decoration-layout].
             * @param side a side
             */
            set_side(side: PackType | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace WindowGroup {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * `GtkWindowGroup` makes group of windows behave like separate applications.
         *
         * It achieves this by limiting the effect of GTK grabs and modality
         * to windows in the same group.
         *
         * A window can be a member in at most one window group at a time.
         * Windows that have not been explicitly assigned to a group are
         * implicitly treated like windows of the default window group.
         *
         * `GtkWindowGroup` objects are referenced by each window in the group,
         * so once you have added all windows to a `GtkWindowGroup`, you can drop
         * the initial reference to the window group with g_object_unref(). If the
         * windows in the window group are subsequently destroyed, then they will
         * be removed from the window group and drop their references on the window
         * group; when all window have been removed, the window group will be
         * freed.
         */
        class WindowGroup extends GObject.Object {
            static $gtype: GObject.GType<WindowGroup>;

            // Constructors

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

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

            static ['new'](): WindowGroup;

            // Methods

            /**
             * Adds a window to a `GtkWindowGroup`.
             * @param window the `GtkWindow` to add
             */
            add_window(window: Window): void;
            /**
             * Returns a list of the `GtkWindows` that belong to `window_group`.
             * @returns A   newly-allocated list of windows inside the group.
             */
            list_windows(): Window[];
            /**
             * Removes a window from a `GtkWindowGroup`.
             * @param window the `GtkWindow` to remove
             */
            remove_window(window: Window): void;
        }

        namespace WindowHandle {
            // Constructor properties interface

            interface ConstructorProps
                extends Widget.ConstructorProps,
                    Accessible.ConstructorProps,
                    Buildable.ConstructorProps,
                    ConstraintTarget.ConstructorProps {
                child: Widget;
            }
        }

        /**
         * `GtkWindowHandle` is a titlebar area widget.
         *
         * When added into a window, it can be dragged to move the window, and handles
         * right click, double click and middle click as expected of a titlebar.
         *
         * # CSS nodes
         *
         * `GtkWindowHandle` has a single CSS node with the name `windowhandle`.
         *
         * # Accessibility
         *
         * Until GTK 4.10, `GtkWindowHandle` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
         *
         * Starting from GTK 4.12, `GtkWindowHandle` uses the `GTK_ACCESSIBLE_ROLE_GENERIC` role.
         */
        class WindowHandle extends Widget implements Accessible, Buildable, ConstraintTarget {
            static $gtype: GObject.GType<WindowHandle>;

            // Properties

            /**
             * The child widget.
             */
            get child(): Widget;
            set child(val: Widget);

            // Constructors

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

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

            static ['new'](): WindowHandle;

            // Methods

            /**
             * Gets the child widget of `self`.
             * @returns the child widget of @self
             */
            get_child(): Widget | null;
            /**
             * Sets the child widget of `self`.
             * @param child the child widget
             */
            set_child(child?: Widget | null): void;

            // Inherited properties
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Inherited methods
            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;
            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        type ATContextClass = typeof ATContext;
        type AccessibleInterface = typeof Accessible;
        /**
         * A boxed type which wraps a list of references to GtkAccessible objects.
         */
        class AccessibleList {
            static $gtype: GObject.GType<AccessibleList>;

            // Constructors

            constructor(accessibles: Accessible[]);
            _init(...args: any[]): void;

            static new_from_array(accessibles: Accessible[]): AccessibleList;

            static new_from_list(list: Accessible[]): AccessibleList;

            // Methods

            /**
             * Gets the list of objects this boxed type holds
             * @returns a shallow copy of the objects
             */
            get_objects(): Accessible[];
        }

        type AccessibleRangeInterface = typeof AccessibleRange;
        type AccessibleTextInterface = typeof AccessibleText;
        /**
         * A range inside the text of an accessible object.
         */
        class AccessibleTextRange {
            static $gtype: GObject.GType<AccessibleTextRange>;

            // Fields

            start: number;
            length: number;

            // Constructors

            constructor(
                properties?: Partial<{
                    start: number;
                    length: number;
                }>,
            );
            _init(...args: any[]): void;
        }

        type ActionableInterface = typeof Actionable;
        type ActivateActionClass = typeof ActivateAction;
        type AdjustmentClass = typeof Adjustment;
        type AlertDialogClass = typeof AlertDialog;
        type AlternativeTriggerClass = typeof AlternativeTrigger;
        type AnyFilterClass = typeof AnyFilter;
        type ApplicationClass = typeof Application;
        type ApplicationWindowClass = typeof ApplicationWindow;
        type BinLayoutClass = typeof BinLayout;
        /**
         * A `GtkBitset` represents a set of unsigned integers.
         *
         * Another name for this data structure is "bitmap".
         *
         * The current implementation is based on [roaring bitmaps](https://roaringbitmap.org/).
         *
         * A bitset allows adding a set of integers and provides support for set operations
         * like unions, intersections and checks for equality or if a value is contained
         * in the set. `GtkBitset` also contains various functions to query metadata about
         * the bitset, such as the minimum or maximum values or its size.
         *
         * The fastest way to iterate values in a bitset is [struct`Gtk`.BitsetIter].
         *
         * The main use case for `GtkBitset` is implementing complex selections for
         * [iface`Gtk`.SelectionModel].
         */
        class Bitset {
            static $gtype: GObject.GType<Bitset>;

            // Constructors

            constructor(properties?: Partial<{}>);
            _init(...args: any[]): void;

            static new_empty(): Bitset;

            static new_range(start: number, n_items: number): Bitset;

            // Methods

            /**
             * Adds `value` to `self` if it wasn't part of it before.
             * @param value value to add
             * @returns %TRUE if @value was not part of @self and @self   was changed
             */
            add(value: number): boolean;
            /**
             * Adds all values from `start` (inclusive) to `start` + `n_items`
             * (exclusive) in `self`.
             * @param start first value to add
             * @param n_items number of consecutive values to add
             */
            add_range(start: number, n_items: number): void;
            /**
             * Adds the closed range [`first,` `last]`, so `first,` `last` and all
             * values in between. `first` must be smaller than `last`.
             * @param first first value to add
             * @param last last value to add
             */
            add_range_closed(first: number, last: number): void;
            /**
             * Interprets the values as a 2-dimensional boolean grid with the given `stride`
             * and inside that grid, adds a rectangle with the given `width` and `height`.
             * @param start first value to add
             * @param width width of the rectangle
             * @param height height of the rectangle
             * @param stride row stride of the grid
             */
            add_rectangle(start: number, width: number, height: number, stride: number): void;
            /**
             * Checks if the given `value` has been added to `self`
             * @param value the value to check
             * @returns %TRUE if @self contains @value
             */
            contains(value: number): boolean;
            /**
             * Creates a copy of `self`.
             * @returns A new bitset that contains the same   values as @self
             */
            copy(): Bitset;
            /**
             * Sets `self` to be the symmetric difference of `self` and `other`.
             *
             * The symmetric difference is set `self` to contain all values that
             * were either contained in `self` or in `other,` but not in both.
             * This operation is also called an XOR.
             *
             * It is allowed for `self` and `other` to be the same bitset. The bitset
             * will be emptied in that case.
             * @param other the `GtkBitset` to compute the difference from
             */
            difference(other: Bitset): void;
            /**
             * Returns %TRUE if `self` and `other` contain the same values.
             * @param other another `GtkBitset`
             * @returns %TRUE if @self and @other contain the same values
             */
            equals(other: Bitset): boolean;
            /**
             * Returns the largest value in `self`.
             *
             * If `self` is empty, 0 is returned.
             * @returns The largest value in @self
             */
            get_maximum(): number;
            /**
             * Returns the smallest value in `self`.
             *
             * If `self` is empty, `G_MAXUINT` is returned.
             * @returns The smallest value in @self
             */
            get_minimum(): number;
            /**
             * Returns the value of the `nth` item in self.
             *
             * If `nth` is >= the size of `self,` 0 is returned.
             * @param nth index of the item to get
             * @returns the value of the @nth item in @self
             */
            get_nth(nth: number): number;
            /**
             * Gets the number of values that were added to the set.
             *
             * For example, if the set is empty, 0 is returned.
             *
             * Note that this function returns a `guint64`, because when all
             * values are set, the return value is `G_MAXUINT + 1`. Unless you
             * are sure this cannot happen (it can't with `GListModel`), be sure
             * to use a 64bit type.
             * @returns The number of values in the set.
             */
            get_size(): number;
            /**
             * Gets the number of values that are part of the set from `first` to `last`
             * (inclusive).
             *
             * Note that this function returns a `guint64`, because when all values are
             * set, the return value is `G_MAXUINT + 1`. Unless you are sure this cannot
             * happen (it can't with `GListModel`), be sure to use a 64bit type.
             * @param first the first element to include
             * @param last the last element to include
             * @returns The number of values in the set from @first to @last.
             */
            get_size_in_range(first: number, last: number): number;
            /**
             * Sets `self` to be the intersection of `self` and `other`.
             *
             * In other words, remove all values from `self` that are not part of `other`.
             *
             * It is allowed for `self` and `other` to be the same bitset. Nothing will
             * happen in that case.
             * @param other the `GtkBitset` to intersect with
             */
            intersect(other: Bitset): void;
            /**
             * Check if no value is contained in bitset.
             * @returns %TRUE if @self is empty
             */
            is_empty(): boolean;
            /**
             * Acquires a reference on the given `GtkBitset`.
             * @returns the `GtkBitset` with an additional reference
             */
            ref(): Bitset;
            /**
             * Removes `value` from `self` if it was part of it before.
             * @param value value to remove
             * @returns %TRUE if @value was part of @self and @self   was changed
             */
            remove(value: number): boolean;
            /**
             * Removes all values from the bitset so that it is empty again.
             */
            remove_all(): void;
            /**
             * Removes all values from `start` (inclusive) to `start` + `n_items` (exclusive)
             * in `self`.
             * @param start first value to remove
             * @param n_items number of consecutive values to remove
             */
            remove_range(start: number, n_items: number): void;
            /**
             * Removes the closed range [`first,` `last]`, so `first,` `last` and all
             * values in between. `first` must be smaller than `last`.
             * @param first first value to remove
             * @param last last value to remove
             */
            remove_range_closed(first: number, last: number): void;
            /**
             * Interprets the values as a 2-dimensional boolean grid with the given `stride`
             * and inside that grid, removes a rectangle with the given `width` and `height`.
             * @param start first value to remove
             * @param width width of the rectangle
             * @param height height of the rectangle
             * @param stride row stride of the grid
             */
            remove_rectangle(start: number, width: number, height: number, stride: number): void;
            /**
             * Shifts all values in `self` to the left by `amount`.
             *
             * Values smaller than `amount` are discarded.
             * @param amount amount to shift all values to the left
             */
            shift_left(amount: number): void;
            /**
             * Shifts all values in `self` to the right by `amount`.
             *
             * Values that end up too large to be held in a #guint are discarded.
             * @param amount amount to shift all values to the right
             */
            shift_right(amount: number): void;
            /**
             * This is a support function for `GListModel` handling, by mirroring
             * the `GlistModel::items-changed` signal.
             *
             * First, it "cuts" the values from `position` to `removed` from
             * the bitset. That is, it removes all those values and shifts
             * all larger values to the left by `removed` places.
             *
             * Then, it "pastes" new room into the bitset by shifting all values
             * larger than `position` by `added` spaces to the right. This frees
             * up space that can then be filled.
             * @param position position at which to slice
             * @param removed number of values to remove
             * @param added number of values to add
             */
            splice(position: number, removed: number, added: number): void;
            /**
             * Sets `self` to be the subtraction of `other` from `self`.
             *
             * In other words, remove all values from `self` that are part of `other`.
             *
             * It is allowed for `self` and `other` to be the same bitset. The bitset
             * will be emptied in that case.
             * @param other the `GtkBitset` to subtract
             */
            subtract(other: Bitset): void;
            /**
             * Sets `self` to be the union of `self` and `other`.
             *
             * That is, add all values from `other` into `self` that weren't part of it.
             *
             * It is allowed for `self` and `other` to be the same bitset. Nothing will
             * happen in that case.
             * @param other the `GtkBitset` to union with
             */
            union(other: Bitset): void;
            /**
             * Releases a reference on the given `GtkBitset`.
             *
             * If the reference was the last, the resources associated to the `self` are
             * freed.
             */
            unref(): void;
        }

        /**
         * An opaque, stack-allocated struct for iterating
         * over the elements of a `GtkBitset`.
         *
         * Before a `GtkBitsetIter` can be used, it needs to be initialized with
         * [func`Gtk`.BitsetIter.init_first], [func`Gtk`.BitsetIter.init_last]
         * or [func`Gtk`.BitsetIter.init_at].
         */
        class BitsetIter {
            static $gtype: GObject.GType<BitsetIter>;

            // Constructors

            constructor(properties?: Partial<{}>);
            _init(...args: any[]): void;

            // Static methods

            /**
             * Initializes `iter` to point to `target`.
             *
             * If `target` is not found, finds the next value after it.
             * If no value >= `target` exists in `set,` this function returns %FALSE.
             * @param set a `GtkBitset`
             * @param target target value to start iterating at
             */
            static init_at(set: Bitset, target: number): [boolean, BitsetIter, number];
            /**
             * Initializes an iterator for `set` and points it to the first
             * value in `set`.
             *
             * If `set` is empty, %FALSE is returned and `value` is set to %G_MAXUINT.
             * @param set a `GtkBitset`
             */
            static init_first(set: Bitset): [boolean, BitsetIter, number];
            /**
             * Initializes an iterator for `set` and points it to the last
             * value in `set`.
             *
             * If `set` is empty, %FALSE is returned.
             * @param set a `GtkBitset`
             */
            static init_last(set: Bitset): [boolean, BitsetIter, number];

            // Methods

            /**
             * Gets the current value that `iter` points to.
             *
             * If `iter` is not valid and [method`Gtk`.BitsetIter.is_valid]
             * returns %FALSE, this function returns 0.
             * @returns The current value pointer to by @iter
             */
            get_value(): number;
            /**
             * Checks if `iter` points to a valid value.
             * @returns %TRUE if @iter points to a valid value
             */
            is_valid(): boolean;
            /**
             * Moves `iter` to the next value in the set.
             *
             * If it was already pointing to the last value in the set,
             * %FALSE is returned and `iter` is invalidated.
             * @returns %TRUE if a next value existed
             */
            next(): [boolean, number];
            /**
             * Moves `iter` to the previous value in the set.
             *
             * If it was already pointing to the first value in the set,
             * %FALSE is returned and `iter` is invalidated.
             * @returns %TRUE if a previous value existed
             */
            previous(): [boolean, number];
        }

        type BookmarkListClass = typeof BookmarkList;
        type BoolFilterClass = typeof BoolFilter;
        /**
         * A struct that specifies a border around a rectangular area.
         *
         * Each side can have different width.
         */
        class Border {
            static $gtype: GObject.GType<Border>;

            // Fields

            left: number;
            right: number;
            top: number;
            bottom: number;

            // Constructors

            constructor(
                properties?: Partial<{
                    left: number;
                    right: number;
                    top: number;
                    bottom: number;
                }>,
            );
            _init(...args: any[]): void;

            static ['new'](): Border;

            // Methods

            /**
             * Copies a `GtkBorder`.
             * @returns a copy of @border_.
             */
            copy(): Border;
            /**
             * Frees a `GtkBorder`.
             */
            free(): void;
        }

        type BoxClass = typeof Box;
        type BoxLayoutClass = typeof BoxLayout;
        type BuildableIface = typeof Buildable;
        /**
         * An opaque context struct for `GtkBuildableParser`.
         */
        abstract class BuildableParseContext {
            static $gtype: GObject.GType<BuildableParseContext>;

            // Constructors

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

            // Methods

            /**
             * Retrieves the name of the currently open element.
             *
             * If called from the start_element or end_element handlers this will
             * give the element_name as passed to those functions. For the parent
             * elements, see gtk_buildable_parse_context_get_element_stack().
             * @returns the name of the currently open element
             */
            get_element(): string | null;
            /**
             * Retrieves the element stack from the internal state of the parser.
             *
             * The returned `GPtrArray` is an array of strings where the last item is
             * the currently open tag (as would be returned by
             * gtk_buildable_parse_context_get_element()) and the previous item is its
             * immediate parent.
             *
             * This function is intended to be used in the start_element and
             * end_element handlers where gtk_buildable_parse_context_get_element()
             * would merely return the name of the element that is being
             * processed.
             * @returns the element stack, which must not be modified
             */
            get_element_stack(): string[];
            /**
             * Retrieves the current line number and the number of the character on
             * that line. Intended for use in error messages; there are no strict
             * semantics for what constitutes the "current" line number other than
             * "the best number we could come up with for error messages."
             */
            get_position(): [number, number];
            /**
             * Completes the process of a temporary sub-parser redirection.
             *
             * This function exists to collect the user_data allocated by a
             * matching call to gtk_buildable_parse_context_push(). It must be called
             * in the end_element handler corresponding to the start_element
             * handler during which gtk_buildable_parse_context_push() was called.
             * You must not call this function from the error callback -- the
             * `user_data` is provided directly to the callback in that case.
             *
             * This function is not intended to be directly called by users
             * interested in invoking subparsers. Instead, it is intended to
             * be used by the subparsers themselves to implement a higher-level
             * interface.
             * @returns the user data passed to gtk_buildable_parse_context_push()
             */
            pop(): any | null;
            /**
             * Temporarily redirects markup data to a sub-parser.
             *
             * This function may only be called from the start_element handler of
             * a `GtkBuildableParser`. It must be matched with a corresponding call to
             * gtk_buildable_parse_context_pop() in the matching end_element handler
             * (except in the case that the parser aborts due to an error).
             *
             * All tags, text and other data between the matching tags is
             * redirected to the subparser given by `parser`. `user_data` is used
             * as the user_data for that parser. `user_data` is also passed to the
             * error callback in the event that an error occurs. This includes
             * errors that occur in subparsers of the subparser.
             *
             * The end tag matching the start tag for which this call was made is
             * handled by the previous parser (which is given its own user_data)
             * which is why gtk_buildable_parse_context_pop() is provided to allow "one
             * last access" to the `user_data` provided to this function. In the
             * case of error, the `user_data` provided here is passed directly to
             * the error callback of the subparser and gtk_buildable_parse_context_pop()
             * should not be called. In either case, if `user_data` was allocated
             * then it ought to be freed from both of these locations.
             *
             * This function is not intended to be directly called by users
             * interested in invoking subparsers. Instead, it is intended to be
             * used by the subparsers themselves to implement a higher-level
             * interface.
             *
             * For an example of how to use this, see g_markup_parse_context_push() which
             * has the same kind of API.
             * @param parser a `GtkBuildableParser`
             * @param user_data user data to pass to `GtkBuildableParser` functions
             */
            push(parser: BuildableParser, user_data?: any | null): void;
        }

        /**
         * A sub-parser for `GtkBuildable` implementations.
         */
        class BuildableParser {
            static $gtype: GObject.GType<BuildableParser>;

            // Constructors

            constructor(properties?: Partial<{}>);
            _init(...args: any[]): void;
        }

        type BuilderCScopeClass = typeof BuilderCScope;
        type BuilderClass = typeof Builder;
        type BuilderListItemFactoryClass = typeof BuilderListItemFactory;
        type BuilderScopeInterface = typeof BuilderScope;
        type ButtonClass = typeof Button;
        abstract class ButtonPrivate {
            static $gtype: GObject.GType<ButtonPrivate>;

            // Constructors

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

        type CallbackActionClass = typeof CallbackAction;
        type CellAreaClass = typeof CellArea;
        type CellAreaContextClass = typeof CellAreaContext;
        abstract class CellAreaContextPrivate {
            static $gtype: GObject.GType<CellAreaContextPrivate>;

            // Constructors

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

        type CellEditableIface = typeof CellEditable;
        type CellLayoutIface = typeof CellLayout;
        type CellRendererClass = typeof CellRenderer;
        abstract class CellRendererClassPrivate {
            static $gtype: GObject.GType<CellRendererClassPrivate>;

            // Constructors

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

        abstract class CellRendererPrivate {
            static $gtype: GObject.GType<CellRendererPrivate>;

            // Constructors

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

        type CellRendererTextClass = typeof CellRendererText;
        type CenterBoxClass = typeof CenterBox;
        type CenterLayoutClass = typeof CenterLayout;
        type CheckButtonClass = typeof CheckButton;
        type ColorChooserInterface = typeof ColorChooser;
        type ColorDialogButtonClass = typeof ColorDialogButton;
        type ColorDialogClass = typeof ColorDialog;
        type ColumnViewCellClass = typeof ColumnViewCell;
        type ColumnViewClass = typeof ColumnView;
        type ColumnViewColumnClass = typeof ColumnViewColumn;
        type ColumnViewRowClass = typeof ColumnViewRow;
        type ColumnViewSorterClass = typeof ColumnViewSorter;
        type ComboBoxClass = typeof ComboBox;
        type ConstraintClass = typeof Constraint;
        type ConstraintGuideClass = typeof ConstraintGuide;
        type ConstraintLayoutChildClass = typeof ConstraintLayoutChild;
        type ConstraintLayoutClass = typeof ConstraintLayout;
        type ConstraintTargetInterface = typeof ConstraintTarget;
        /**
         * A description of a location inside a CSS stream.
         */
        class CssLocation {
            static $gtype: GObject.GType<CssLocation>;

            // Fields

            bytes: number;
            chars: number;
            lines: number;
            line_bytes: number;
            line_chars: number;

            // Constructors

            constructor(
                properties?: Partial<{
                    bytes: number;
                    chars: number;
                    lines: number;
                    line_bytes: number;
                    line_chars: number;
                }>,
            );
            _init(...args: any[]): void;
        }

        type CssProviderClass = typeof CssProvider;
        abstract class CssProviderPrivate {
            static $gtype: GObject.GType<CssProviderPrivate>;

            // Constructors

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

        /**
         * Defines a part of a CSS document.
         *
         * Because sections are nested into one another, you can use
         * [method`CssSection`.get_parent] to get the containing region.
         */
        class CssSection {
            static $gtype: GObject.GType<CssSection>;

            // Constructors

            constructor(file: Gio.File | null, start: CssLocation, end: CssLocation);
            _init(...args: any[]): void;

            static ['new'](file: Gio.File | null, start: CssLocation, end: CssLocation): CssSection;

            static new_with_bytes(
                file: Gio.File | null,
                bytes: GLib.Bytes | null,
                start: CssLocation,
                end: CssLocation,
            ): CssSection;

            // Methods

            /**
             * Gets the bytes that `section` was parsed from.
             * @returns the `GBytes` from which the `section`   was parsed
             */
            get_bytes(): GLib.Bytes | null;
            /**
             * Returns the location in the CSS document where this section ends.
             * @returns The end location of   this section
             */
            get_end_location(): CssLocation;
            /**
             * Gets the file that `section` was parsed from.
             *
             * If no such file exists, for example because the CSS was loaded via
             * [method`Gtk`.CssProvider.load_from_data], then `NULL` is returned.
             * @returns the `GFile` from which the `section`   was parsed
             */
            get_file(): Gio.File | null;
            /**
             * Gets the parent section for the given `section`.
             *
             * The parent section is the section that contains this `section`. A special
             * case are sections of  type `GTK_CSS_SECTION_DOCUMEN`T. Their parent will
             * either be `NULL` if they are the original CSS document that was loaded by
             * [method`Gtk`.CssProvider.load_from_file] or a section of type
             * `GTK_CSS_SECTION_IMPORT` if it was loaded with an ``import`` rule from
             * a different file.
             * @returns the parent section
             */
            get_parent(): CssSection | null;
            /**
             * Returns the location in the CSS document where this section starts.
             * @returns The start location of   this section
             */
            get_start_location(): CssLocation;
            /**
             * Prints the `section` into `string` in a human-readable form.
             *
             * This is a form like `gtk.css:32:1-23` to denote line 32, characters
             * 1 to 23 in the file `gtk.css`.
             * @param string a `GString` to print to
             */
            print(string: GLib.String): void;
            /**
             * Increments the reference count on `section`.
             * @returns the CSS section itself.
             */
            ref(): CssSection;
            /**
             * Prints the section into a human-readable text form using
             * [method`Gtk`.CssSection.print].
             * @returns A new string.
             */
            to_string(): string;
            /**
             * Decrements the reference count on `section`, freeing the
             * structure if the reference count reaches 0.
             */
            unref(): void;
        }

        /**
         * A CSS style change.
         */
        abstract class CssStyleChange {
            static $gtype: GObject.GType<CssStyleChange>;

            // Constructors

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

        type CustomFilterClass = typeof CustomFilter;
        type CustomLayoutClass = typeof CustomLayout;
        type CustomSorterClass = typeof CustomSorter;
        type DialogClass = typeof Dialog;
        type DirectoryListClass = typeof DirectoryList;
        type DragIconClass = typeof DragIcon;
        type DragSourceClass = typeof DragSource;
        type DrawingAreaClass = typeof DrawingArea;
        type DropControllerMotionClass = typeof DropControllerMotion;
        type DropDownClass = typeof DropDown;
        type DropTargetAsyncClass = typeof DropTargetAsync;
        type DropTargetClass = typeof DropTarget;
        type EditableInterface = typeof Editable;
        type EditableLabelClass = typeof EditableLabel;
        type EmojiChooserClass = typeof EmojiChooser;
        type EntryBufferClass = typeof EntryBuffer;
        type EntryClass = typeof Entry;
        type EventControllerClass = typeof EventController;
        type EventControllerFocusClass = typeof EventControllerFocus;
        type EventControllerKeyClass = typeof EventControllerKey;
        type EventControllerLegacyClass = typeof EventControllerLegacy;
        type EventControllerMotionClass = typeof EventControllerMotion;
        type EventControllerScrollClass = typeof EventControllerScroll;
        type EveryFilterClass = typeof EveryFilter;
        /**
         * An opaque structure representing a watched `GtkExpression`.
         *
         * The contents of `GtkExpressionWatch` should only be accessed through the
         * provided API.
         */
        abstract class ExpressionWatch {
            static $gtype: GObject.GType<ExpressionWatch>;

            // Constructors

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

            // Methods

            /**
             * Evaluates the watched expression and on success stores the result
             * in `value`.
             *
             * This is equivalent to calling [method`Gtk`.Expression.evaluate] with the
             * expression and this pointer originally used to create `watch`.
             * @param value an empty `GValue` to be set
             * @returns `TRUE` if the expression could be evaluated and `value` was set
             */
            evaluate(value: GObject.Value | any): boolean;
            /**
             * Acquires a reference on the given `GtkExpressionWatch`.
             * @returns the `GtkExpressionWatch` with an additional reference
             */
            ref(): ExpressionWatch;
            /**
             * Releases a reference on the given `GtkExpressionWatch`.
             *
             * If the reference was the last, the resources associated to `self` are
             * freed.
             */
            unref(): void;
            /**
             * Stops watching an expression.
             *
             * See [method`Gtk`.Expression.watch] for how the watch
             * was established.
             */
            unwatch(): void;
        }

        type FileChooserNativeClass = typeof FileChooserNative;
        type FileDialogClass = typeof FileDialog;
        type FileLauncherClass = typeof FileLauncher;
        type FilterClass = typeof Filter;
        type FilterListModelClass = typeof FilterListModel;
        type FixedClass = typeof Fixed;
        type FixedLayoutChildClass = typeof FixedLayoutChild;
        type FixedLayoutClass = typeof FixedLayout;
        type FlattenListModelClass = typeof FlattenListModel;
        type FlowBoxChildClass = typeof FlowBoxChild;
        type FontChooserIface = typeof FontChooser;
        type FontDialogButtonClass = typeof FontDialogButton;
        type FontDialogClass = typeof FontDialog;
        type FrameClass = typeof Frame;
        type GLAreaClass = typeof GLArea;
        type GestureClass = typeof Gesture;
        type GestureClickClass = typeof GestureClick;
        type GestureDragClass = typeof GestureDrag;
        type GestureLongPressClass = typeof GestureLongPress;
        type GesturePanClass = typeof GesturePan;
        type GestureRotateClass = typeof GestureRotate;
        type GestureSingleClass = typeof GestureSingle;
        type GestureStylusClass = typeof GestureStylus;
        type GestureSwipeClass = typeof GestureSwipe;
        type GestureZoomClass = typeof GestureZoom;
        type GraphicsOffloadClass = typeof GraphicsOffload;
        type GridClass = typeof Grid;
        type GridLayoutChildClass = typeof GridLayoutChild;
        type GridLayoutClass = typeof GridLayout;
        type GridViewClass = typeof GridView;
        type IMContextClass = typeof IMContext;
        type IMContextSimpleClass = typeof IMContextSimple;
        abstract class IMContextSimplePrivate {
            static $gtype: GObject.GType<IMContextSimplePrivate>;

            // Constructors

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

        type IMMulticontextClass = typeof IMMulticontext;
        abstract class IMMulticontextPrivate {
            static $gtype: GObject.GType<IMMulticontextPrivate>;

            // Constructors

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

        type InscriptionClass = typeof Inscription;
        type KeyvalTriggerClass = typeof KeyvalTrigger;
        type LayoutChildClass = typeof LayoutChild;
        type LayoutManagerClass = typeof LayoutManager;
        type ListBaseClass = typeof ListBase;
        type ListBoxRowClass = typeof ListBoxRow;
        type ListHeaderClass = typeof ListHeader;
        type ListItemClass = typeof ListItem;
        type ListItemFactoryClass = typeof ListItemFactory;
        type ListStoreClass = typeof ListStore;
        abstract class ListStorePrivate {
            static $gtype: GObject.GType<ListStorePrivate>;

            // Constructors

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

        type ListViewClass = typeof ListView;
        type MapListModelClass = typeof MapListModel;
        type MediaControlsClass = typeof MediaControls;
        type MediaFileClass = typeof MediaFile;
        type MediaStreamClass = typeof MediaStream;
        type MessageDialogClass = typeof MessageDialog;
        type MnemonicActionClass = typeof MnemonicAction;
        type MnemonicTriggerClass = typeof MnemonicTrigger;
        type MountOperationClass = typeof MountOperation;
        abstract class MountOperationPrivate {
            static $gtype: GObject.GType<MountOperationPrivate>;

            // Constructors

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

        type MultiFilterClass = typeof MultiFilter;
        type MultiSelectionClass = typeof MultiSelection;
        type MultiSorterClass = typeof MultiSorter;
        type NamedActionClass = typeof NamedAction;
        type NativeDialogClass = typeof NativeDialog;
        type NativeInterface = typeof Native;
        type NeverTriggerClass = typeof NeverTrigger;
        type NoSelectionClass = typeof NoSelection;
        type NothingActionClass = typeof NothingAction;
        type NumericSorterClass = typeof NumericSorter;
        type OrientableIface = typeof Orientable;
        type OverlayLayoutChildClass = typeof OverlayLayoutChild;
        type OverlayLayoutClass = typeof OverlayLayout;
        /**
         * Struct defining a pad action entry.
         */
        class PadActionEntry {
            static $gtype: GObject.GType<PadActionEntry>;

            // Fields

            type: PadActionType;
            index: number;
            mode: number;
            label: string;
            action_name: string;

            // Constructors

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

        type PadControllerClass = typeof PadController;
        /**
         * A range of pages to print.
         *
         * See also [method`Gtk`.PrintSettings.set_page_ranges].
         */
        class PageRange {
            static $gtype: GObject.GType<PageRange>;

            // Fields

            start: number;
            end: number;

            // Constructors

            constructor(
                properties?: Partial<{
                    start: number;
                    end: number;
                }>,
            );
            _init(...args: any[]): void;
        }

        /**
         * `GtkPaperSize` handles paper sizes.
         *
         * It uses the standard called
         * [PWG 5101.1-2002 PWG: Standard for Media Standardized Names](http://www.pwg.org/standards.html)
         * to name the paper sizes (and to get the data for the page sizes).
         * In addition to standard paper sizes, `GtkPaperSize` allows to
         * construct custom paper sizes with arbitrary dimensions.
         *
         * The `GtkPaperSize` object stores not only the dimensions (width
         * and height) of a paper size and its name, it also provides
         * default print margins.
         */
        class PaperSize {
            static $gtype: GObject.GType<PaperSize>;

            // Constructors

            constructor(name?: string | null);
            _init(...args: any[]): void;

            static ['new'](name?: string | null): PaperSize;

            static new_custom(name: string, display_name: string, width: number, height: number, unit: Unit): PaperSize;

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

            static new_from_ipp(ipp_name: string, width: number, height: number): PaperSize;

            static new_from_key_file(key_file: GLib.KeyFile, group_name?: string | null): PaperSize;

            static new_from_ppd(ppd_name: string, ppd_display_name: string, width: number, height: number): PaperSize;

            // Static methods

            /**
             * Returns the name of the default paper size, which
             * depends on the current locale.
             */
            static get_default(): string;
            /**
             * Creates a list of known paper sizes.
             * @param include_custom whether to include custom paper sizes   as defined in the page setup dialog
             */
            static get_paper_sizes(include_custom: boolean): PaperSize[];

            // Methods

            /**
             * Copies an existing `GtkPaperSize`.
             * @returns a copy of @other
             */
            copy(): PaperSize;
            /**
             * Free the given `GtkPaperSize` object.
             */
            free(): void;
            /**
             * Gets the default bottom margin for the `GtkPaperSize`.
             * @param unit the unit for the return value, not %GTK_UNIT_NONE
             * @returns the default bottom margin
             */
            get_default_bottom_margin(unit: Unit | null): number;
            /**
             * Gets the default left margin for the `GtkPaperSize`.
             * @param unit the unit for the return value, not %GTK_UNIT_NONE
             * @returns the default left margin
             */
            get_default_left_margin(unit: Unit | null): number;
            /**
             * Gets the default right margin for the `GtkPaperSize`.
             * @param unit the unit for the return value, not %GTK_UNIT_NONE
             * @returns the default right margin
             */
            get_default_right_margin(unit: Unit | null): number;
            /**
             * Gets the default top margin for the `GtkPaperSize`.
             * @param unit the unit for the return value, not %GTK_UNIT_NONE
             * @returns the default top margin
             */
            get_default_top_margin(unit: Unit | null): number;
            /**
             * Gets the human-readable name of the `GtkPaperSize`.
             * @returns the human-readable name of @size
             */
            get_display_name(): string;
            /**
             * Gets the paper height of the `GtkPaperSize`, in
             * units of `unit`.
             * @param unit the unit for the return value, not %GTK_UNIT_NONE
             * @returns the paper height
             */
            get_height(unit: Unit | null): number;
            /**
             * Gets the name of the `GtkPaperSize`.
             * @returns the name of @size
             */
            get_name(): string;
            /**
             * Gets the PPD name of the `GtkPaperSize`, which
             * may be %NULL.
             * @returns the PPD name of @size
             */
            get_ppd_name(): string;
            /**
             * Gets the paper width of the `GtkPaperSize`, in
             * units of `unit`.
             * @param unit the unit for the return value, not %GTK_UNIT_NONE
             * @returns the paper width
             */
            get_width(unit: Unit | null): number;
            /**
             * Returns %TRUE if `size` is not a standard paper size.
             * @returns whether @size is a custom paper size.
             */
            is_custom(): boolean;
            /**
             * Compares two `GtkPaperSize` objects.
             * @param size2 another `GtkPaperSize` object
             * @returns %TRUE, if @size1 and @size2 represent the same paper size
             */
            is_equal(size2: PaperSize): boolean;
            /**
             * Returns %TRUE if `size` is an IPP standard paper size.
             * @returns whether @size is not an IPP custom paper size.
             */
            is_ipp(): boolean;
            /**
             * Changes the dimensions of a `size` to `width` x `height`.
             * @param width the new width in units of @unit
             * @param height the new height in units of @unit
             * @param unit the unit for @width and @height
             */
            set_size(width: number, height: number, unit: Unit | null): void;
            /**
             * Serialize a paper size to an `a{sv}` variant.
             * @returns a new, floating, `GVariant`
             */
            to_gvariant(): GLib.Variant;
            /**
             * This function adds the paper size from `size` to `key_file`.
             * @param key_file the `GKeyFile` to save the paper size to
             * @param group_name the group to add the settings to in @key_file
             */
            to_key_file(key_file: GLib.KeyFile, group_name: string): void;
        }

        type PasswordEntryBufferClass = typeof PasswordEntryBuffer;
        type PasswordEntryClass = typeof PasswordEntry;
        type PictureClass = typeof Picture;
        type PopoverClass = typeof Popover;
        /**
         * A print backend.
         */
        abstract class PrintBackend {
            static $gtype: GObject.GType<PrintBackend>;

            // Constructors

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

        type PrintDialogClass = typeof PrintDialog;
        type PrintOperationClass = typeof PrintOperation;
        type PrintOperationPreviewIface = typeof PrintOperationPreview;
        abstract class PrintOperationPrivate {
            static $gtype: GObject.GType<PrintOperationPrivate>;

            // Constructors

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

        /**
         * A `GtkPrintSetup` is an auxiliary object for printing that allows decoupling
         * the setup from the printing.
         *
         * A print setup is obtained by calling [method`Gtk`.PrintDialog.setup],
         * and can later be passed to print functions such as [method`Gtk`.PrintDialog.print].
         *
         * Print setups can be reused for multiple print calls.
         *
         * Applications may wish to store the page_setup and print_settings from the print setup
         * and copy them to the PrintDialog if they want to keep using them.
         */
        abstract class PrintSetup {
            static $gtype: GObject.GType<PrintSetup>;

            // Constructors

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

            // Methods

            /**
             * Returns the page setup of `setup`.
             *
             * It may be different from the `GtkPrintDialog`'s page setup
             * if the user changed it during the setup process.
             * @returns the page setup, or `NULL`
             */
            get_page_setup(): PageSetup;
            /**
             * Returns the print settings of `setup`.
             *
             * They may be different from the `GtkPrintDialog`'s settings
             * if the user changed them during the setup process.
             * @returns the print settings, or `NULL`
             */
            get_print_settings(): PrintSettings;
            /**
             * Increase the reference count of `setup`.
             * @returns the print setup
             */
            ref(): PrintSetup;
            /**
             * Decrease the reference count of `setup`.
             *
             * If the reference count reaches zero,
             * the object is freed.
             */
            unref(): void;
        }

        type RangeClass = typeof Range;
        /**
         * Meta-data to be passed to gtk_recent_manager_add_full() when
         * registering a recently used resource.
         */
        class RecentData {
            static $gtype: GObject.GType<RecentData>;

            // Fields

            display_name: string;
            description: string;
            mime_type: string;
            app_name: string;
            app_exec: string;
            groups: string[];
            is_private: boolean;

            // Constructors

            constructor(
                properties?: Partial<{
                    display_name: string;
                    description: string;
                    mime_type: string;
                    app_name: string;
                    app_exec: string;
                    groups: string[];
                    is_private: boolean;
                }>,
            );
            _init(...args: any[]): void;
        }

        /**
         * `GtkRecentInfo` contains the metadata associated with an item in the
         * recently used files list.
         */
        abstract class RecentInfo {
            static $gtype: GObject.GType<RecentInfo>;

            // Constructors

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

            // Methods

            /**
             * Creates a `GAppInfo` for the specified `GtkRecentInfo`
             *
             * In case of error, `error` will be set either with a
             * %GTK_RECENT_MANAGER_ERROR or a %G_IO_ERROR
             * @param app_name the name of the application that should   be mapped to a `GAppInfo`; if %NULL is used then the default   application for the MIME type is used
             * @returns the newly created `GAppInfo`
             */
            create_app_info(app_name?: string | null): Gio.AppInfo | null;
            /**
             * Checks whether the resource pointed by `info` still exists.
             * At the moment this check is done only on resources pointing
             * to local files.
             * @returns %TRUE if the resource exists
             */
            exists(): boolean;
            /**
             * Gets the time when the resource
             * was added to the recently used resources list.
             * @returns a `GDateTime` for the time    when the resource was added
             */
            get_added(): GLib.DateTime;
            /**
             * Gets the number of days elapsed since the last update
             * of the resource pointed by `info`.
             * @returns a positive integer containing the number of days   elapsed since the time this resource was last modified
             */
            get_age(): number;
            /**
             * Gets the data regarding the application that has registered the resource
             * pointed by `info`.
             *
             * If the command line contains any escape characters defined inside the
             * storage specification, they will be expanded.
             * @param app_name the name of the application that has registered this item
             * @returns %TRUE if an application with @app_name has registered this   resource inside the recently used list, or %FALSE otherwise. The   @app_exec string is owned by the `GtkRecentInfo` and should not be   modified or freed
             */
            get_application_info(app_name: string): [boolean, string, number, GLib.DateTime];
            /**
             * Retrieves the list of applications that have registered this resource.
             * @returns a newly   allocated %NULL-terminated array of strings. Use g_strfreev() to free it.
             */
            get_applications(): string[];
            /**
             * Gets the (short) description of the resource.
             * @returns the description of the resource. The returned string   is owned by the recent manager, and should not be freed.
             */
            get_description(): string;
            /**
             * Gets the name of the resource.
             *
             * If none has been defined, the basename
             * of the resource is obtained.
             * @returns the display name of the resource. The returned string   is owned by the recent manager, and should not be freed.
             */
            get_display_name(): string;
            /**
             * Retrieves the icon associated to the resource MIME type.
             * @returns a `GIcon` containing the icon
             */
            get_gicon(): Gio.Icon | null;
            /**
             * Returns all groups registered for the recently used item `info`.
             *
             * The array of returned group names will be %NULL terminated, so
             * length might optionally be %NULL.
             * @returns a newly allocated %NULL terminated array of strings.   Use g_strfreev() to free it.
             */
            get_groups(): string[];
            /**
             * Gets the MIME type of the resource.
             * @returns the MIME type of the resource. The returned string   is owned by the recent manager, and should not be freed.
             */
            get_mime_type(): string;
            /**
             * Gets the time when the meta-data
             * for the resource was last modified.
             * @returns a `GDateTime` for the time   when the resource was last modified
             */
            get_modified(): GLib.DateTime;
            /**
             * Gets the value of the “private” flag.
             *
             * Resources in the recently used list that have this flag
             * set to %TRUE should only be displayed by the applications
             * that have registered them.
             * @returns %TRUE if the private flag was found, %FALSE otherwise
             */
            get_private_hint(): boolean;
            /**
             * Computes a valid UTF-8 string that can be used as the
             * name of the item in a menu or list.
             *
             * For example, calling this function on an item that refers
             * to “file:///foo/bar.txt” will yield “bar.txt”.
             * @returns A newly-allocated string in UTF-8 encoding   free it with g_free()
             */
            get_short_name(): string;
            /**
             * Gets the URI of the resource.
             * @returns the URI of the resource. The returned string is   owned by the recent manager, and should not be freed.
             */
            get_uri(): string;
            /**
             * Gets a displayable version of the resource’s URI.
             *
             * If the resource is local, it returns a local path; if the
             * resource is not local, it returns the UTF-8 encoded content
             * of [method`Gtk`.RecentInfo.get_uri].
             * @returns a newly allocated UTF-8 string containing the   resource’s URI or %NULL. Use g_free() when done using it.
             */
            get_uri_display(): string | null;
            /**
             * Gets the time when the meta-data
             * for the resource was last visited.
             * @returns a `GDateTime` for the time    when the resource was last visited
             */
            get_visited(): GLib.DateTime;
            /**
             * Checks whether an application registered this resource using `app_name`.
             * @param app_name a string containing an application name
             * @returns %TRUE if an application with name @app_name was found,   %FALSE otherwise
             */
            has_application(app_name: string): boolean;
            /**
             * Checks whether `group_name` appears inside the groups
             * registered for the recently used item `info`.
             * @param group_name name of a group
             * @returns %TRUE if the group was found
             */
            has_group(group_name: string): boolean;
            /**
             * Checks whether the resource is local or not by looking at the
             * scheme of its URI.
             * @returns %TRUE if the resource is local
             */
            is_local(): boolean;
            /**
             * Gets the name of the last application that have registered the
             * recently used resource represented by `info`.
             * @returns an application name. Use g_free() to free it.
             */
            last_application(): string;
            /**
             * Checks whether two `GtkRecentInfo` point to the same resource.
             * @param info_b a `GtkRecentInfo`
             * @returns %TRUE if both `GtkRecentInfo` point to the same   resource, %FALSE otherwise
             */
            match(info_b: RecentInfo): boolean;
            /**
             * Increases the reference count of `recent_info` by one.
             * @returns the recent info object with its reference count   increased by one
             */
            ref(): RecentInfo;
            /**
             * Decreases the reference count of `info` by one.
             *
             * If the reference count reaches zero, `info` is
             * deallocated, and the memory freed.
             */
            unref(): void;
        }

        type RecentManagerClass = typeof RecentManager;
        abstract class RecentManagerPrivate {
            static $gtype: GObject.GType<RecentManagerPrivate>;

            // Constructors

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

        /**
         * Represents a request of a screen object in a given orientation. These
         * are primarily used in container implementations when allocating a natural
         * size for children calling. See [func`distribute_natural_allocation]`.
         */
        class RequestedSize {
            static $gtype: GObject.GType<RequestedSize>;

            // Fields

            data: any;
            minimum_size: number;
            natural_size: number;

            // Constructors

            constructor(
                properties?: Partial<{
                    data: any;
                    minimum_size: number;
                    natural_size: number;
                }>,
            );
            _init(...args: any[]): void;
        }

        /**
         * A `GtkRequisition` represents the desired size of a widget. See
         * [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
         * more information.
         */
        class Requisition {
            static $gtype: GObject.GType<Requisition>;

            // Fields

            width: number;
            height: number;

            // Constructors

            constructor(
                properties?: Partial<{
                    width: number;
                    height: number;
                }>,
            );
            _init(...args: any[]): void;

            static ['new'](): Requisition;

            // Methods

            /**
             * Copies a `GtkRequisition`.
             * @returns a copy of @requisition
             */
            copy(): Requisition;
            /**
             * Frees a `GtkRequisition`.
             */
            free(): void;
        }

        type RootInterface = typeof Root;
        type ScaleButtonClass = typeof ScaleButton;
        type ScaleClass = typeof Scale;
        /**
         * The `GtkScrollInfo` can be used to provide more accurate data on how a scroll
         * operation should be performed.
         *
         * Scrolling functions usually allow passing a %NULL scroll info which will cause
         * the default values to be used and just scroll the element into view.
         */
        class ScrollInfo {
            static $gtype: GObject.GType<ScrollInfo>;

            // Constructors

            constructor(properties?: Partial<{}>);
            _init(...args: any[]): void;

            static ['new'](): ScrollInfo;

            // Methods

            /**
             * Checks if horizontal scrolling is enabled.
             * @returns %TRUE if horizontal scrolling is enabled.
             */
            get_enable_horizontal(): boolean;
            /**
             * Checks if vertical scrolling is enabled.
             * @returns %TRUE if vertical scrolling is enabled.
             */
            get_enable_vertical(): boolean;
            /**
             * Increases the reference count of a `GtkScrollInfo` by one.
             * @returns the passed in `GtkScrollInfo`.
             */
            ref(): ScrollInfo;
            /**
             * Turns horizontal scrolling on or off.
             * @param horizontal if scrolling in the horizontal direction     should happen
             */
            set_enable_horizontal(horizontal: boolean): void;
            /**
             * Turns vertical scrolling on or off.
             * @param vertical if scrolling in the vertical direction     should happen
             */
            set_enable_vertical(vertical: boolean): void;
            /**
             * Decreases the reference count of a `GtkScrollInfo` by one.
             *
             * If the resulting reference count is zero, frees the self.
             */
            unref(): void;
        }

        type ScrollableInterface = typeof Scrollable;
        type SectionModelInterface = typeof SectionModel;
        type SelectionFilterModelClass = typeof SelectionFilterModel;
        type SelectionModelInterface = typeof SelectionModel;
        type ShortcutActionClass = typeof ShortcutAction;
        type ShortcutClass = typeof Shortcut;
        type ShortcutControllerClass = typeof ShortcutController;
        type ShortcutLabelClass = typeof ShortcutLabel;
        type ShortcutManagerInterface = typeof ShortcutManager;
        type ShortcutTriggerClass = typeof ShortcutTrigger;
        type ShortcutsGroupClass = typeof ShortcutsGroup;
        type ShortcutsSectionClass = typeof ShortcutsSection;
        type ShortcutsShortcutClass = typeof ShortcutsShortcut;
        type SignalActionClass = typeof SignalAction;
        type SignalListItemFactoryClass = typeof SignalListItemFactory;
        type SingleSelectionClass = typeof SingleSelection;
        type SliceListModelClass = typeof SliceListModel;
        type SnapshotClass = typeof Snapshot;
        type SortListModelClass = typeof SortListModel;
        type SorterClass = typeof Sorter;
        type StringFilterClass = typeof StringFilter;
        type StringListClass = typeof StringList;
        type StringObjectClass = typeof StringObject;
        type StringSorterClass = typeof StringSorter;
        type StyleContextClass = typeof StyleContext;
        type SymbolicPaintableInterface = typeof SymbolicPaintable;
        type TextBufferClass = typeof TextBuffer;
        abstract class TextBufferPrivate {
            static $gtype: GObject.GType<TextBufferPrivate>;

            // Constructors

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

        type TextChildAnchorClass = typeof TextChildAnchor;
        /**
         * An iterator for the contents of a `GtkTextBuffer`.
         *
         * You may wish to begin by reading the
         * [text widget conceptual overview](section-text-widget.html),
         * which gives an overview of all the objects and data types
         * related to the text widget and how they work together.
         */
        class TextIter {
            static $gtype: GObject.GType<TextIter>;

            // Constructors

            constructor(properties?: Partial<{}>);
            _init(...args: any[]): void;

            // Methods

            /**
             * Assigns the value of `other` to `iter`.
             *
             * This function is not useful in applications, because
             * iterators can be assigned with `GtkTextIter i = j;`.
             *
             * The function is used by language bindings.
             * @param other another `GtkTextIter`
             */
            assign(other: TextIter): void;
            /**
             * Moves backward by one character offset.
             *
             * Returns %TRUE if movement was possible; if `iter` was the first
             * in the buffer (character offset 0), this function returns %FALSE
             * for convenience when writing loops.
             * @returns whether movement was possible
             */
            backward_char(): boolean;
            /**
             * Moves `count` characters backward, if possible.
             *
             * If `count` would move past the start or end of the buffer, moves
             * to the start or end of the buffer.
             *
             * The return value indicates whether the iterator moved
             * onto a dereferenceable position; if the iterator didn’t move, or
             * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
             * the function does nothing and returns %FALSE.
             * @param count number of characters to move
             * @returns whether @iter moved and is dereferenceable
             */
            backward_chars(count: number): boolean;
            /**
             * Like [method`Gtk`.TextIter.forward_cursor_position], but moves backward.
             * @returns %TRUE if we moved
             */
            backward_cursor_position(): boolean;
            /**
             * Moves up to `count` cursor positions.
             *
             * See [method`Gtk`.TextIter.forward_cursor_position] for details.
             * @param count number of positions to move
             * @returns %TRUE if we moved and the new position is dereferenceable
             */
            backward_cursor_positions(count: number): boolean;
            /**
             * Same as [method`Gtk`.TextIter.forward_find_char],
             * but goes backward from `iter`.
             * @param pred function to be called on each character
             * @param limit search limit
             * @returns whether a match was found
             */
            backward_find_char(pred: TextCharPredicate, limit?: TextIter | null): boolean;
            /**
             * Moves `iter` to the start of the previous line.
             *
             * Returns %TRUE if `iter` could be moved; i.e. if `iter` was at
             * character offset 0, this function returns %FALSE. Therefore,
             * if `iter` was already on line 0, but not at the start of the line,
             * `iter` is snapped to the start of the line and the function returns
             * %TRUE. (Note that this implies that
             * in a loop calling this function, the line number may not change on
             * every iteration, if your first iteration is on line 0.)
             * @returns whether @iter moved
             */
            backward_line(): boolean;
            /**
             * Moves `count` lines backward, if possible.
             *
             * If `count` would move past the start or end of the buffer, moves to
             * the start or end of the buffer.
             *
             * The return value indicates whether the iterator moved
             * onto a dereferenceable position; if the iterator didn’t move, or
             * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
             * the function does nothing and returns %FALSE. If `count` is negative,
             * moves forward by 0 - `count` lines.
             * @param count number of lines to move backward
             * @returns whether @iter moved and is dereferenceable
             */
            backward_lines(count: number): boolean;
            /**
             * Same as [method`Gtk`.TextIter.forward_search], but moves backward.
             *
             * `match_end` will never be set to a `GtkTextIter` located after `iter,`
             * even if there is a possible `match_start` before or at `iter`.
             * @param str search string
             * @param flags bitmask of flags affecting the search
             * @param limit location of last possible @match_start, or %NULL for start of buffer
             * @returns whether a match was found
             */
            backward_search(
                str: string,
                flags: TextSearchFlags | null,
                limit?: TextIter | null,
            ): [boolean, TextIter | null, TextIter | null];
            /**
             * Moves backward to the previous sentence start.
             *
             * If `iter` is already at the start of a sentence, moves backward
             * to the next one.
             *
             * Sentence boundaries are determined by Pango and should
             * be correct for nearly any language.
             * @returns %TRUE if @iter moved and is not the end iterator
             */
            backward_sentence_start(): boolean;
            /**
             * Calls [method`Gtk`.TextIter.backward_sentence_start] up to `count` times.
             *
             * If `count` is negative, moves forward instead of backward.
             * @param count number of sentences to move
             * @returns %TRUE if @iter moved and is not the end iterator
             */
            backward_sentence_starts(count: number): boolean;
            /**
             * Moves backward to the next toggle (on or off) of the
             * `tag,` or to the next toggle of any tag if
             * `tag` is %NULL.
             *
             * If no matching tag toggles are found,
             * returns %FALSE, otherwise %TRUE. Does not return toggles
             * located at `iter,` only toggles before `iter`. Sets `iter`
             * to the location of the toggle, or the start of the buffer
             * if no toggle is found.
             * @param tag a `GtkTextTag`
             * @returns whether we found a tag toggle before @iter
             */
            backward_to_tag_toggle(tag?: TextTag | null): boolean;
            /**
             * Moves `iter` backward to the previous visible cursor position.
             *
             * See [method`Gtk`.TextIter.backward_cursor_position] for details.
             * @returns %TRUE if we moved and the new position is dereferenceable
             */
            backward_visible_cursor_position(): boolean;
            /**
             * Moves up to `count` visible cursor positions.
             *
             * See [method`Gtk`.TextIter.backward_cursor_position] for details.
             * @param count number of positions to move
             * @returns %TRUE if we moved and the new position is dereferenceable
             */
            backward_visible_cursor_positions(count: number): boolean;
            /**
             * Moves `iter` to the start of the previous visible line.
             *
             * Returns %TRUE if
             * `iter` could be moved; i.e. if `iter` was at character offset 0, this
             * function returns %FALSE. Therefore if `iter` was already on line 0,
             * but not at the start of the line, `iter` is snapped to the start of
             * the line and the function returns %TRUE. (Note that this implies that
             * in a loop calling this function, the line number may not change on
             * every iteration, if your first iteration is on line 0.)
             * @returns whether @iter moved
             */
            backward_visible_line(): boolean;
            /**
             * Moves `count` visible lines backward, if possible.
             *
             * If `count` would move past the start or end of the buffer, moves to
             * the start or end of the buffer.
             *
             * The return value indicates whether the iterator moved
             * onto a dereferenceable position; if the iterator didn’t move, or
             * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
             * the function does nothing and returns %FALSE. If `count` is negative,
             * moves forward by 0 - `count` lines.
             * @param count number of lines to move backward
             * @returns whether @iter moved and is dereferenceable
             */
            backward_visible_lines(count: number): boolean;
            /**
             * Moves backward to the previous visible word start.
             *
             * If `iter` is currently on a word start, moves backward to the
             * next one after that.
             *
             * Word breaks are determined by Pango and should be correct
             * for nearly any language.
             * @returns %TRUE if @iter moved and is not the end iterator
             */
            backward_visible_word_start(): boolean;
            /**
             * Calls [method`Gtk`.TextIter.backward_visible_word_start] up to `count` times.
             * @param count number of times to move
             * @returns %TRUE if @iter moved and is not the end iterator
             */
            backward_visible_word_starts(count: number): boolean;
            /**
             * Moves backward to the previous word start.
             *
             * If `iter` is currently on a word start, moves backward to the
             * next one after that.
             *
             * Word breaks are determined by Pango and should be correct
             * for nearly any language
             * @returns %TRUE if @iter moved and is not the end iterator
             */
            backward_word_start(): boolean;
            /**
             * Calls [method`Gtk`.TextIter.backward_word_start] up to `count` times.
             * @param count number of times to move
             * @returns %TRUE if @iter moved and is not the end iterator
             */
            backward_word_starts(count: number): boolean;
            /**
             * Considering the default editability of the buffer, and tags that
             * affect editability, determines whether text inserted at `iter` would
             * be editable.
             *
             * If text inserted at `iter` would be editable then the
             * user should be allowed to insert text at `iter`.
             * [method`Gtk`.TextBuffer.insert_interactive] uses this function
             * to decide whether insertions are allowed at a given position.
             * @param default_editability %TRUE if text is editable by default
             * @returns whether text inserted at @iter would be editable
             */
            can_insert(default_editability: boolean): boolean;
            /**
             * A qsort()-style function that returns negative if `lhs` is less than
             * `rhs,` positive if `lhs` is greater than `rhs,` and 0 if they’re equal.
             *
             * Ordering is in character offset order, i.e. the first character
             * in the buffer is less than the second character in the buffer.
             * @param rhs another `GtkTextIter`
             * @returns -1 if @lhs is less than @rhs, 1 if @lhs is greater, 0 if they are equal
             */
            compare(rhs: TextIter): number;
            /**
             * Creates a dynamically-allocated copy of an iterator.
             *
             * This function is not useful in applications, because
             * iterators can be copied with a simple assignment
             * (`GtkTextIter i = j;`).
             *
             * The function is used by language bindings.
             * @returns a copy of the @iter, free with [method@Gtk.TextIter.free]
             */
            copy(): TextIter;
            /**
             * Returns whether the character at `iter` is within an editable region
             * of text.
             *
             * Non-editable text is “locked” and can’t be changed by the
             * user via `GtkTextView`. If no tags applied to this text affect
             * editability, `default_setting` will be returned.
             *
             * You don’t want to use this function to decide whether text can be
             * inserted at `iter,` because for insertion you don’t want to know
             * whether the char at `iter` is inside an editable range, you want to
             * know whether a new character inserted at `iter` would be inside an
             * editable range. Use [method`Gtk`.TextIter.can_insert] to handle this
             * case.
             * @param default_setting %TRUE if text is editable by default
             * @returns whether @iter is inside an editable range
             */
            editable(default_setting: boolean): boolean;
            /**
             * Returns %TRUE if `iter` points to the start of the paragraph
             * delimiter characters for a line.
             *
             * Delimiters will be either a newline, a carriage return, a carriage
             * return followed by a newline, or a Unicode paragraph separator
             * character.
             *
             * Note that an iterator pointing to the \n of a \r\n pair will not be
             * counted as the end of a line, the line ends before the \r. The end
             * iterator is considered to be at the end of a line, even though there
             * are no paragraph delimiter chars there.
             * @returns whether @iter is at the end of a line
             */
            ends_line(): boolean;
            /**
             * Determines whether `iter` ends a sentence.
             *
             * Sentence boundaries are determined by Pango and should
             * be correct for nearly any language.
             * @returns %TRUE if @iter is at the end of a sentence.
             */
            ends_sentence(): boolean;
            /**
             * Returns %TRUE if `tag` is toggled off at exactly this point.
             *
             * If `tag` is %NULL, returns %TRUE if any tag is toggled off at this point.
             *
             * Note that if this function returns %TRUE, it means that
             * `iter` is at the end of the tagged range, but that the character
             * at `iter` is outside the tagged range. In other words,
             * unlike [method`Gtk`.TextIter.starts_tag], if this function
             * returns %TRUE, [method`Gtk`.TextIter.has_tag] will return
             * %FALSE for the same parameters.
             * @param tag a `GtkTextTag`
             * @returns whether @iter is the end of a range tagged with @tag
             */
            ends_tag(tag?: TextTag | null): boolean;
            /**
             * Determines whether `iter` ends a natural-language word.
             *
             * Word breaks are determined by Pango and should be correct
             * for nearly any language.
             * @returns %TRUE if @iter is at the end of a word
             */
            ends_word(): boolean;
            /**
             * Tests whether two iterators are equal, using the fastest possible
             * mechanism.
             *
             * This function is very fast; you can expect it to perform
             * better than e.g. getting the character offset for each
             * iterator and comparing the offsets yourself. Also, it’s a
             * bit faster than [method`Gtk`.TextIter.compare].
             * @param rhs another `GtkTextIter`
             * @returns %TRUE if the iterators point to the same place in the buffer
             */
            equal(rhs: TextIter): boolean;
            /**
             * Moves `iter` forward by one character offset.
             *
             * Note that images embedded in the buffer occupy 1 character slot, so
             * this function may actually move onto an image instead of a character,
             * if you have images in your buffer. If `iter` is the end iterator or
             * one character before it, `iter` will now point at the end iterator,
             * and this function returns %FALSE for convenience when writing loops.
             * @returns whether @iter moved and is dereferenceable
             */
            forward_char(): boolean;
            /**
             * Moves `count` characters if possible.
             *
             * If `count` would move past the start or end of the buffer,
             * moves to the start or end of the buffer.
             *
             * The return value indicates whether the new position of
             * `iter` is different from its original position, and dereferenceable
             * (the last iterator in the buffer is not dereferenceable). If `count`
             * is 0, the function does nothing and returns %FALSE.
             * @param count number of characters to move, may be negative
             * @returns whether @iter moved and is dereferenceable
             */
            forward_chars(count: number): boolean;
            /**
             * Moves `iter` forward by a single cursor position.
             *
             * Cursor positions are (unsurprisingly) positions where the
             * cursor can appear. Perhaps surprisingly, there may not be
             * a cursor position between all characters. The most common
             * example for European languages would be a carriage return/newline
             * sequence.
             *
             * For some Unicode characters, the equivalent of say the letter “a”
             * with an accent mark will be represented as two characters, first
             * the letter then a "combining mark" that causes the accent to be
             * rendered; so the cursor can’t go between those two characters.
             *
             * See also the [struct`Pango`.LogAttr] struct and the [func`Pango`.break]
             * function.
             * @returns %TRUE if we moved and the new position is dereferenceable
             */
            forward_cursor_position(): boolean;
            /**
             * Moves up to `count` cursor positions.
             *
             * See [method`Gtk`.TextIter.forward_cursor_position] for details.
             * @param count number of positions to move
             * @returns %TRUE if we moved and the new position is dereferenceable
             */
            forward_cursor_positions(count: number): boolean;
            /**
             * Advances `iter,` calling `pred` on each character.
             *
             * If `pred` returns %TRUE, returns %TRUE and stops scanning.
             * If `pred` never returns %TRUE, `iter` is set to `limit` if
             * `limit` is non-%NULL, otherwise to the end iterator.
             * @param pred a function to be called on each character
             * @param limit search limit
             * @returns whether a match was found
             */
            forward_find_char(pred: TextCharPredicate, limit?: TextIter | null): boolean;
            /**
             * Moves `iter` to the start of the next line.
             *
             * If the iter is already on the last line of the buffer,
             * moves the iter to the end of the current line. If after
             * the operation, the iter is at the end of the buffer and not
             * dereferenceable, returns %FALSE. Otherwise, returns %TRUE.
             * @returns whether @iter can be dereferenced
             */
            forward_line(): boolean;
            /**
             * Moves `count` lines forward, if possible.
             *
             * If `count` would move past the start or end of the buffer, moves to
             * the start or end of the buffer.
             *
             * The return value indicates whether the iterator moved
             * onto a dereferenceable position; if the iterator didn’t move, or
             * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
             * the function does nothing and returns %FALSE. If `count` is negative,
             * moves backward by 0 - `count` lines.
             * @param count number of lines to move forward
             * @returns whether @iter moved and is dereferenceable
             */
            forward_lines(count: number): boolean;
            /**
             * Searches forward for `str`.
             *
             * Any match is returned by setting `match_start` to the first character
             * of the match and `match_end` to the first character after the match.
             * The search will not continue past `limit`. Note that a search is a
             * linear or O(n) operation, so you may wish to use `limit` to avoid
             * locking up your UI on large buffers.
             *
             * `match_start` will never be set to a `GtkTextIter` located before `iter,`
             * even if there is a possible `match_end` after or at `iter`.
             * @param str a search string
             * @param flags flags affecting how the search is done
             * @param limit location of last possible @match_end, or %NULL for the end of the buffer
             * @returns whether a match was found
             */
            forward_search(
                str: string,
                flags: TextSearchFlags | null,
                limit?: TextIter | null,
            ): [boolean, TextIter | null, TextIter | null];
            /**
             * Moves forward to the next sentence end.
             *
             * If `iter` is at the end of a sentence, moves to the next
             * end of sentence.
             *
             * Sentence boundaries are determined by Pango and should
             * be correct for nearly any language.
             * @returns %TRUE if @iter moved and is not the end iterator
             */
            forward_sentence_end(): boolean;
            /**
             * Calls [method`Gtk`.TextIter.forward_sentence_end] `count` times.
             *
             * If `count` is negative, moves backward instead of forward.
             * @param count number of sentences to move
             * @returns %TRUE if @iter moved and is not the end iterator
             */
            forward_sentence_ends(count: number): boolean;
            /**
             * Moves `iter` forward to the “end iterator”, which points
             * one past the last valid character in the buffer.
             *
             * [method`Gtk`.TextIter.get_char] called on the end iterator
             * returns 0, which is convenient for writing loops.
             */
            forward_to_end(): void;
            /**
             * Moves the iterator to point to the paragraph delimiter characters.
             *
             * The possible characters are either a newline, a carriage return,
             * a carriage return/newline in sequence, or the Unicode paragraph
             * separator character.
             *
             * If the iterator is already at the paragraph delimiter
             * characters, moves to the paragraph delimiter characters for the
             * next line. If `iter` is on the last line in the buffer, which does
             * not end in paragraph delimiters, moves to the end iterator (end of
             * the last line), and returns %FALSE.
             * @returns %TRUE if we moved and the new location is not the end iterator
             */
            forward_to_line_end(): boolean;
            /**
             * Moves forward to the next toggle (on or off) of the
             * `tag,` or to the next toggle of any tag if
             * `tag` is %NULL.
             *
             * If no matching tag toggles are found,
             * returns %FALSE, otherwise %TRUE. Does not return toggles
             * located at `iter,` only toggles after `iter`. Sets `iter` to
             * the location of the toggle, or to the end of the buffer
             * if no toggle is found.
             * @param tag a `GtkTextTag`
             * @returns whether we found a tag toggle after @iter
             */
            forward_to_tag_toggle(tag?: TextTag | null): boolean;
            /**
             * Moves `iter` forward to the next visible cursor position.
             *
             * See [method`Gtk`.TextIter.forward_cursor_position] for details.
             * @returns %TRUE if we moved and the new position is dereferenceable
             */
            forward_visible_cursor_position(): boolean;
            /**
             * Moves up to `count` visible cursor positions.
             *
             * See [method`Gtk`.TextIter.forward_cursor_position] for details.
             * @param count number of positions to move
             * @returns %TRUE if we moved and the new position is dereferenceable
             */
            forward_visible_cursor_positions(count: number): boolean;
            /**
             * Moves `iter` to the start of the next visible line.
             *
             * Returns %TRUE if there
             * was a next line to move to, and %FALSE if `iter` was simply moved to
             * the end of the buffer and is now not dereferenceable, or if `iter` was
             * already at the end of the buffer.
             * @returns whether @iter can be dereferenced
             */
            forward_visible_line(): boolean;
            /**
             * Moves `count` visible lines forward, if possible.
             *
             * If `count` would move past the start or end of the buffer, moves to
             * the start or end of the buffer.
             *
             * The return value indicates whether the iterator moved
             * onto a dereferenceable position; if the iterator didn’t move, or
             * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
             * the function does nothing and returns %FALSE. If `count` is negative,
             * moves backward by 0 - `count` lines.
             * @param count number of lines to move forward
             * @returns whether @iter moved and is dereferenceable
             */
            forward_visible_lines(count: number): boolean;
            /**
             * Moves forward to the next visible word end.
             *
             * If `iter` is currently on a word end, moves forward to the
             * next one after that.
             *
             * Word breaks are determined by Pango and should be correct
             * for nearly any language
             * @returns %TRUE if @iter moved and is not the end iterator
             */
            forward_visible_word_end(): boolean;
            /**
             * Calls [method`Gtk`.TextIter.forward_visible_word_end] up to `count` times.
             * @param count number of times to move
             * @returns %TRUE if @iter moved and is not the end iterator
             */
            forward_visible_word_ends(count: number): boolean;
            /**
             * Moves forward to the next word end.
             *
             * If `iter` is currently on a word end, moves forward to the
             * next one after that.
             *
             * Word breaks are determined by Pango and should be correct
             * for nearly any language.
             * @returns %TRUE if @iter moved and is not the end iterator
             */
            forward_word_end(): boolean;
            /**
             * Calls [method`Gtk`.TextIter.forward_word_end] up to `count` times.
             * @param count number of times to move
             * @returns %TRUE if @iter moved and is not the end iterator
             */
            forward_word_ends(count: number): boolean;
            /**
             * Free an iterator allocated on the heap.
             *
             * This function is intended for use in language bindings,
             * and is not especially useful for applications, because
             * iterators can simply be allocated on the stack.
             */
            free(): void;
            /**
             * Returns the `GtkTextBuffer` this iterator is associated with.
             * @returns the buffer
             */
            get_buffer(): TextBuffer;
            /**
             * Returns the number of bytes in the line containing `iter,`
             * including the paragraph delimiters.
             * @returns number of bytes in the line
             */
            get_bytes_in_line(): number;
            /**
             * The Unicode character at this iterator is returned.
             *
             * Equivalent to operator* on a C++ iterator. If the element at
             * this iterator is a non-character element, such as an image
             * embedded in the buffer, the Unicode “unknown” character 0xFFFC
             * is returned. If invoked on the end iterator, zero is returned;
             * zero is not a valid Unicode character.
             *
             * So you can write a loop which ends when this function returns 0.
             * @returns a Unicode character, or 0 if @iter is not dereferenceable
             */
            get_char(): number;
            /**
             * Returns the number of characters in the line containing `iter,`
             * including the paragraph delimiters.
             * @returns number of characters in the line
             */
            get_chars_in_line(): number;
            /**
             * If the location at `iter` contains a child anchor, the
             * anchor is returned.
             *
             * Otherwise, %NULL is returned.
             * @returns the anchor at @iter
             */
            get_child_anchor(): TextChildAnchor | null;
            /**
             * Returns the language in effect at `iter`.
             *
             * If no tags affecting language apply to `iter,` the return
             * value is identical to that of [func`Gtk`.get_default_language].
             * @returns language in effect at @iter
             */
            get_language(): Pango.Language;
            /**
             * Returns the line number containing the iterator.
             *
             * Lines in a `GtkTextBuffer` are numbered beginning
             * with 0 for the first line in the buffer.
             * @returns a line number
             */
            get_line(): number;
            /**
             * Returns the byte index of the iterator, counting
             * from the start of a newline-terminated line.
             *
             * Remember that `GtkTextBuffer` encodes text in
             * UTF-8, and that characters can require a variable
             * number of bytes to represent.
             * @returns distance from start of line, in bytes
             */
            get_line_index(): number;
            /**
             * Returns the character offset of the iterator,
             * counting from the start of a newline-terminated line.
             *
             * The first character on the line has offset 0.
             * @returns offset from start of line
             */
            get_line_offset(): number;
            /**
             * Returns a list of all `GtkTextMark` at this location.
             *
             * Because marks are not iterable (they don’t take up any "space"
             * in the buffer, they are just marks in between iterable locations),
             * multiple marks can exist in the same place.
             *
             * The returned list is not in any meaningful order.
             * @returns list of `GtkTextMark`
             */
            get_marks(): TextMark[];
            /**
             * Returns the character offset of an iterator.
             *
             * Each character in a `GtkTextBuffer` has an offset,
             * starting with 0 for the first character in the buffer.
             * Use [method`Gtk`.TextBuffer.get_iter_at_offset] to convert
             * an offset back into an iterator.
             * @returns a character offset
             */
            get_offset(): number;
            /**
             * If the element at `iter` is a paintable, the paintable is returned.
             *
             * Otherwise, %NULL is returned.
             * @returns the paintable at @iter
             */
            get_paintable(): Gdk.Paintable | null;
            /**
             * Returns the text in the given range.
             *
             * A “slice” is an array of characters encoded in UTF-8 format,
             * including the Unicode “unknown” character 0xFFFC for iterable
             * non-character elements in the buffer, such as images.
             * Because images are encoded in the slice, byte and
             * character offsets in the returned array will correspond to byte
             * offsets in the text buffer. Note that 0xFFFC can occur in normal
             * text as well, so it is not a reliable indicator that a paintable or
             * widget is in the buffer.
             * @param end iterator at end of a range
             * @returns slice of text from the buffer
             */
            get_slice(end: TextIter): string;
            /**
             * Returns a list of tags that apply to `iter,` in ascending order of
             * priority.
             *
             * The highest-priority tags are last.
             *
             * The `GtkTextTag`s in the list don’t have a reference added,
             * but you have to free the list itself.
             * @returns list of   `GtkTextTag`
             */
            get_tags(): TextTag[];
            /**
             * Returns text in the given range.
             *
             * If the range
             * contains non-text elements such as images, the character and byte
             * offsets in the returned string will not correspond to character and
             * byte offsets in the buffer. If you want offsets to correspond, see
             * [method`Gtk`.TextIter.get_slice].
             * @param end iterator at end of a range
             * @returns array of characters from the buffer
             */
            get_text(end: TextIter): string;
            /**
             * Returns a list of `GtkTextTag` that are toggled on or off at this
             * point.
             *
             * If `toggled_on` is %TRUE, the list contains tags that are
             * toggled on. If a tag is toggled on at `iter,` then some non-empty
             * range of characters following `iter` has that tag applied to it.  If
             * a tag is toggled off, then some non-empty range following `iter`
             * does not have the tag applied to it.
             * @param toggled_on %TRUE to get toggled-on tags
             * @returns tags   toggled at this point
             */
            get_toggled_tags(toggled_on: boolean): TextTag[];
            /**
             * Returns the number of bytes from the start of the
             * line to the given `iter,` not counting bytes that
             * are invisible due to tags with the “invisible” flag
             * toggled on.
             * @returns byte index of @iter with respect to the start of the line
             */
            get_visible_line_index(): number;
            /**
             * Returns the offset in characters from the start of the
             * line to the given `iter,` not counting characters that
             * are invisible due to tags with the “invisible” flag
             * toggled on.
             * @returns offset in visible characters from the start of the line
             */
            get_visible_line_offset(): number;
            /**
             * Returns visible text in the given range.
             *
             * Like [method`Gtk`.TextIter.get_slice], but invisible text
             * is not included. Invisible text is usually invisible because
             * a `GtkTextTag` with the “invisible” attribute turned on has
             * been applied to it.
             * @param end iterator at end of range
             * @returns slice of text from the buffer
             */
            get_visible_slice(end: TextIter): string;
            /**
             * Returns visible text in the given range.
             *
             * Like [method`Gtk`.TextIter.get_text], but invisible text
             * is not included. Invisible text is usually invisible because
             * a `GtkTextTag` with the “invisible” attribute turned on has
             * been applied to it.
             * @param end iterator at end of range
             * @returns string containing visible text in the range
             */
            get_visible_text(end: TextIter): string;
            /**
             * Returns %TRUE if `iter` points to a character that is part
             * of a range tagged with `tag`.
             *
             * See also [method`Gtk`.TextIter.starts_tag] and
             * [method`Gtk`.TextIter.ends_tag].
             * @param tag a `GtkTextTag`
             * @returns whether @iter is tagged with @tag
             */
            has_tag(tag: TextTag): boolean;
            /**
             * Checks whether `iter` falls in the range [`start,` `end)`.
             *
             * `start` and `end` must be in ascending order.
             * @param start start of range
             * @param end end of range
             * @returns %TRUE if @iter is in the range
             */
            in_range(start: TextIter, end: TextIter): boolean;
            /**
             * Determines whether `iter` is inside a sentence (as opposed to in
             * between two sentences, e.g. after a period and before the first
             * letter of the next sentence).
             *
             * Sentence boundaries are determined by Pango and should be correct
             * for nearly any language.
             * @returns %TRUE if @iter is inside a sentence.
             */
            inside_sentence(): boolean;
            /**
             * Determines whether the character pointed by `iter` is part of a
             * natural-language word (as opposed to say inside some whitespace).
             *
             * Word breaks are determined by Pango and should be correct
             * for nearly any language.
             *
             * Note that if [method`Gtk`.TextIter.starts_word] returns %TRUE,
             * then this function returns %TRUE too, since `iter` points to
             * the first character of the word.
             * @returns %TRUE if @iter is inside a word
             */
            inside_word(): boolean;
            /**
             * Determine if `iter` is at a cursor position.
             *
             * See [method`Gtk`.TextIter.forward_cursor_position] or
             * [struct`Pango`.LogAttr] or [func`Pango`.break] for details
             * on what a cursor position is.
             * @returns %TRUE if the cursor can be placed at @iter
             */
            is_cursor_position(): boolean;
            /**
             * Returns %TRUE if `iter` is the end iterator.
             *
             * This means it is one past the last dereferenceable iterator
             * in the buffer. [method`Gtk`.TextIter.is_end] is the most efficient
             * way to check whether an iterator is the end iterator.
             * @returns whether @iter is the end iterator
             */
            is_end(): boolean;
            /**
             * Returns %TRUE if `iter` is the first iterator in the buffer.
             * @returns whether @iter is the first in the buffer
             */
            is_start(): boolean;
            /**
             * Swaps the value of `first` and `second` if `second` comes before
             * `first` in the buffer.
             *
             * That is, ensures that `first` and `second` are in sequence.
             * Most text buffer functions that take a range call this
             * automatically on your behalf, so there’s no real reason to
             * call it yourself in those cases. There are some exceptions,
             * such as [method`Gtk`.TextIter.in_range], that expect a
             * pre-sorted range.
             * @param second another `GtkTextIter`
             */
            order(second: TextIter): void;
            /**
             * Moves iterator `iter` to the start of the line `line_number`.
             *
             * If `line_number` is negative or larger than or equal to the number of lines
             * in the buffer, moves `iter` to the start of the last line in the buffer.
             * @param line_number line number (counted from 0)
             */
            set_line(line_number: number): void;
            /**
             * Same as [method`Gtk`.TextIter.set_line_offset], but works with a
             * byte index. The given byte index must be at
             * the start of a character, it can’t be in the middle of a UTF-8
             * encoded character.
             * @param byte_on_line a byte index relative to the start of @iter’s current line
             */
            set_line_index(byte_on_line: number): void;
            /**
             * Moves `iter` within a line, to a new character (not byte) offset.
             *
             * The given character offset must be less than or equal to the number
             * of characters in the line; if equal, `iter` moves to the start of the
             * next line. See [method`Gtk`.TextIter.set_line_index] if you have a byte
             * index rather than a character offset.
             * @param char_on_line a character offset relative to the start of @iter’s current line
             */
            set_line_offset(char_on_line: number): void;
            /**
             * Sets `iter` to point to `char_offset`.
             *
             * `char_offset` counts from the start
             * of the entire text buffer, starting with 0.
             * @param char_offset a character number
             */
            set_offset(char_offset: number): void;
            /**
             * Like [method`Gtk`.TextIter.set_line_index], but the index is in visible
             * bytes, i.e. text with a tag making it invisible is not counted
             * in the index.
             * @param byte_on_line a byte index
             */
            set_visible_line_index(byte_on_line: number): void;
            /**
             * Like [method`Gtk`.TextIter.set_line_offset], but the offset is in visible
             * characters, i.e. text with a tag making it invisible is not
             * counted in the offset.
             * @param char_on_line a character offset
             */
            set_visible_line_offset(char_on_line: number): void;
            /**
             * Returns %TRUE if `iter` begins a paragraph.
             *
             * This is the case if [method`Gtk`.TextIter.get_line_offset]
             * would return 0. However this function is potentially more
             * efficient than [method`Gtk`.TextIter.get_line_offset], because
             * it doesn’t have to compute the offset, it just has to see
             * whether it’s 0.
             * @returns whether @iter begins a line
             */
            starts_line(): boolean;
            /**
             * Determines whether `iter` begins a sentence.
             *
             * Sentence boundaries are determined by Pango and
             * should be correct for nearly any language.
             * @returns %TRUE if @iter is at the start of a sentence.
             */
            starts_sentence(): boolean;
            /**
             * Returns %TRUE if `tag` is toggled on at exactly this point.
             *
             * If `tag` is %NULL, returns %TRUE if any tag is toggled on at this point.
             *
             * Note that if this function returns %TRUE, it means that
             * `iter` is at the beginning of the tagged range, and that the
             * character at `iter` is inside the tagged range. In other
             * words, unlike [method`Gtk`.TextIter.ends_tag], if
             * this function returns %TRUE, [method`Gtk`.TextIter.has_tag]
             * will also return %TRUE for the same parameters.
             * @param tag a `GtkTextTag`
             * @returns whether @iter is the start of a range tagged with @tag
             */
            starts_tag(tag?: TextTag | null): boolean;
            /**
             * Determines whether `iter` begins a natural-language word.
             *
             * Word breaks are determined by Pango and should be correct
             * for nearly any language.
             * @returns %TRUE if @iter is at the start of a word
             */
            starts_word(): boolean;
            /**
             * Gets whether a range with `tag` applied to it begins
             * or ends at `iter`.
             *
             * This is equivalent to (gtk_text_iter_starts_tag() ||
             * gtk_text_iter_ends_tag())
             * @param tag a `GtkTextTag`
             * @returns whether @tag is toggled on or off at @iter
             */
            toggles_tag(tag?: TextTag | null): boolean;
        }

        type TextMarkClass = typeof TextMark;
        type TextTagClass = typeof TextTag;
        abstract class TextTagPrivate {
            static $gtype: GObject.GType<TextTagPrivate>;

            // Constructors

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

        type TextViewClass = typeof TextView;
        abstract class TextViewPrivate {
            static $gtype: GObject.GType<TextViewPrivate>;

            // Constructors

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

        type ToggleButtonClass = typeof ToggleButton;
        type TreeDragDestIface = typeof TreeDragDest;
        type TreeDragSourceIface = typeof TreeDragSource;
        type TreeExpanderClass = typeof TreeExpander;
        /**
         * The `GtkTreeIter` is the primary structure
         * for accessing a `GtkTreeModel`. Models are expected to put a unique
         * integer in the `stamp` member, and put
         * model-specific data in the three `user_data`
         * members.
         */
        class TreeIter {
            static $gtype: GObject.GType<TreeIter>;

            // Fields

            stamp: number;
            user_data: any;
            user_data2: any;
            user_data3: any;

            // Constructors

            constructor(
                properties?: Partial<{
                    stamp: number;
                    user_data: any;
                    user_data2: any;
                    user_data3: any;
                }>,
            );
            _init(...args: any[]): void;

            // Methods

            /**
             * Creates a dynamically allocated tree iterator as a copy of `iter`.
             *
             * This function is not intended for use in applications,
             * because you can just copy the structs by value
             * (`GtkTreeIter new_iter = iter;`).
             * You must free this iter with gtk_tree_iter_free().
             * @returns a newly-allocated copy of @iter
             */
            copy(): TreeIter;
            /**
             * Frees an iterator that has been allocated by gtk_tree_iter_copy().
             *
             * This function is mainly used for language bindings.
             */
            free(): void;
        }

        type TreeListModelClass = typeof TreeListModel;
        type TreeListRowClass = typeof TreeListRow;
        type TreeListRowSorterClass = typeof TreeListRowSorter;
        type TreeModelFilterClass = typeof TreeModelFilter;
        abstract class TreeModelFilterPrivate {
            static $gtype: GObject.GType<TreeModelFilterPrivate>;

            // Constructors

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

        type TreeModelIface = typeof TreeModel;
        type TreeModelSortClass = typeof TreeModelSort;
        abstract class TreeModelSortPrivate {
            static $gtype: GObject.GType<TreeModelSortPrivate>;

            // Constructors

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

        /**
         * An opaque structure representing a path to a row in a model.
         */
        class TreePath {
            static $gtype: GObject.GType<TreePath>;

            // Constructors

            constructor(properties?: Partial<{}>);
            _init(...args: any[]): void;

            static ['new'](): TreePath;

            static new_first(): TreePath;

            static new_from_indices(indices: number[]): TreePath;

            static new_from_string(path: string): TreePath;

            // Methods

            /**
             * Appends a new index to a path.
             *
             * As a result, the depth of the path is increased.
             * @param index_ the index
             */
            append_index(index_: number): void;
            /**
             * Compares two paths.
             *
             * If `a` appears before `b` in a tree, then -1 is returned.
             * If `b` appears before `a,` then 1 is returned.
             * If the two nodes are equal, then 0 is returned.
             * @param b a `GtkTreePath` to compare with
             * @returns the relative positions of @a and @b
             */
            compare(b: TreePath): number;
            /**
             * Creates a new `GtkTreePath` as a copy of `path`.
             * @returns a new `GtkTreePath`
             */
            copy(): TreePath;
            /**
             * Moves `path` to point to the first child of the current path.
             */
            down(): void;
            /**
             * Frees `path`. If `path` is %NULL, it simply returns.
             */
            free(): void;
            /**
             * Returns the current depth of `path`.
             * @returns The depth of @path
             */
            get_depth(): number;
            /**
             * Returns the current indices of `path`.
             *
             * This is an array of integers, each representing a node in a tree.
             * It also returns the number of elements in the array.
             * The array should not be freed.
             * @returns The current   indices
             */
            get_indices(): number[] | null;
            /**
             * Returns %TRUE if `descendant` is a descendant of `path`.
             * @param descendant another `GtkTreePath`
             * @returns %TRUE if @descendant is contained inside @path
             */
            is_ancestor(descendant: TreePath): boolean;
            /**
             * Returns %TRUE if `path` is a descendant of `ancestor`.
             * @param ancestor another `GtkTreePath`
             * @returns %TRUE if @ancestor contains @path somewhere below it
             */
            is_descendant(ancestor: TreePath): boolean;
            /**
             * Moves the `path` to point to the next node at the current depth.
             */
            next(): void;
            /**
             * Prepends a new index to a path.
             *
             * As a result, the depth of the path is increased.
             * @param index_ the index
             */
            prepend_index(index_: number): void;
            /**
             * Moves the `path` to point to the previous node at the
             * current depth, if it exists.
             * @returns %TRUE if @path has a previous node, and   the move was made
             */
            prev(): boolean;
            /**
             * Generates a string representation of the path.
             *
             * This string is a “:” separated list of numbers.
             * For example, “4:10:0:3” would be an acceptable
             * return value for this string. If the path has
             * depth 0, %NULL is returned.
             * @returns A newly-allocated string
             */
            to_string(): string | null;
            /**
             * Moves the `path` to point to its parent node, if it has a parent.
             * @returns %TRUE if @path has a parent, and the move was made
             */
            up(): boolean;
        }

        /**
         * A GtkTreeRowReference tracks model changes so that it always refers to the
         * same row (a `GtkTreePath` refers to a position, not a fixed row). Create a
         * new GtkTreeRowReference with gtk_tree_row_reference_new().
         */
        class TreeRowReference {
            static $gtype: GObject.GType<TreeRowReference>;

            // Constructors

            constructor(model: TreeModel, path: TreePath);
            _init(...args: any[]): void;

            static ['new'](model: TreeModel, path: TreePath): TreeRowReference;

            static new_proxy(proxy: GObject.Object, model: TreeModel, path: TreePath): TreeRowReference;

            // Static methods

            /**
             * Lets a set of row reference created by
             * gtk_tree_row_reference_new_proxy() know that the
             * model emitted the ::row-deleted signal.
             * @param proxy a `GObject`
             * @param path the path position that was deleted
             */
            static deleted(proxy: GObject.Object, path: TreePath): void;
            /**
             * Lets a set of row reference created by
             * gtk_tree_row_reference_new_proxy() know that the
             * model emitted the ::row-inserted signal.
             * @param proxy a `GObject`
             * @param path the row position that was inserted
             */
            static inserted(proxy: GObject.Object, path: TreePath): void;

            // Methods

            /**
             * Copies a `GtkTreeRowReference`.
             * @returns a copy of @reference
             */
            copy(): TreeRowReference;
            /**
             * Free’s `reference`. `reference` may be %NULL
             */
            free(): void;
            /**
             * Returns the model that the row reference is monitoring.
             * @returns the model
             */
            get_model(): TreeModel;
            /**
             * Returns a path that the row reference currently points to,
             * or %NULL if the path pointed to is no longer valid.
             * @returns a current path
             */
            get_path(): TreePath | null;
            /**
             * Returns %TRUE if the `reference` is non-%NULL and refers to
             * a current valid path.
             * @returns %TRUE if @reference points to a valid path
             */
            valid(): boolean;
        }

        type TreeSortableIface = typeof TreeSortable;
        type TreeStoreClass = typeof TreeStore;
        abstract class TreeStorePrivate {
            static $gtype: GObject.GType<TreeStorePrivate>;

            // Constructors

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

        type TreeViewClass = typeof TreeView;
        type UriLauncherClass = typeof UriLauncher;
        type VideoClass = typeof Video;
        type WidgetClass = typeof Widget;
        abstract class WidgetClassPrivate {
            static $gtype: GObject.GType<WidgetClassPrivate>;

            // Constructors

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

        type WidgetPaintableClass = typeof WidgetPaintable;
        abstract class WidgetPrivate {
            static $gtype: GObject.GType<WidgetPrivate>;

            // Constructors

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

        type WindowClass = typeof Window;
        type WindowControlsClass = typeof WindowControls;
        type WindowGroupClass = typeof WindowGroup;
        abstract class WindowGroupPrivate {
            static $gtype: GObject.GType<WindowGroupPrivate>;

            // Constructors

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

        type WindowHandleClass = typeof WindowHandle;
        namespace Accessible {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                accessible_role: AccessibleRole;
                accessibleRole: AccessibleRole;
            }
        }

        export interface AccessibleNamespace {
            $gtype: GObject.GType<Accessible>;
            prototype: Accessible;
        }
        interface Accessible extends GObject.Object {
            // Properties

            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessible_role(): AccessibleRole;
            set accessible_role(val: AccessibleRole);
            /**
             * The accessible role of the given `GtkAccessible` implementation.
             *
             * The accessible role cannot be changed once set.
             */
            get accessibleRole(): AccessibleRole;
            set accessibleRole(val: AccessibleRole);

            // Methods

            /**
             * Requests the user's screen reader to announce the given message.
             *
             * This kind of notification is useful for messages that
             * either have only a visual representation or that are not
             * exposed visually at all, e.g. a notification about a
             * successful operation.
             *
             * Also, by using this API, you can ensure that the message
             * does not interrupts the user's current screen reader output.
             * @param message the string to announce
             * @param priority the priority of the announcement
             */
            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             * @returns the accessible parent
             */
            get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible role of an accessible object.
             * @returns the accessible role
             */
            get_accessible_role(): AccessibleRole;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             * @returns the accessible implementation object
             */
            get_at_context(): ATContext;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             * @returns true if the bounds are valid, and false otherwise
             */
            get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             * @returns the first accessible child
             */
            get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             * @returns the next accessible sibling
             */
            get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             * @returns the value of @state for the accessible
             */
            get_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Resets the accessible `property` to its default value.
             * @param property a `GtkAccessibleProperty`
             */
            reset_property(property: AccessibleProperty | null): void;
            /**
             * Resets the accessible `relation` to its default value.
             * @param relation a `GtkAccessibleRelation`
             */
            reset_relation(relation: AccessibleRelation | null): void;
            /**
             * Resets the accessible `state` to its default value.
             * @param state a `GtkAccessibleState`
             */
            reset_state(state: AccessibleState | null): void;
            /**
             * Sets the parent and sibling of an accessible object.
             *
             * This function is meant to be used by accessible implementations that are
             * not part of the widget hierarchy, and but act as a logical bridge between
             * widgets. For instance, if a widget creates an object that holds metadata
             * for each child, and you want that object to implement the `GtkAccessible`
             * interface, you will use this function to ensure that the parent of each
             * child widget is the metadata object, and the parent of each metadata
             * object is the container widget.
             * @param parent the parent accessible object
             * @param next_sibling the sibling accessible object
             */
            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
            /**
             * Updates the next accessible sibling of `self`.
             *
             * That might be useful when a new child of a custom `GtkAccessible`
             * is created, and it needs to be linked to a previous child.
             * @param new_sibling the new next accessible sibling to set
             */
            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
            /**
             * Updates an array of accessible properties.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * property change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param properties an array of `GtkAccessibleProperty`
             * @param values an array of `GValues`, one for each property
             */
            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible relations.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * relation change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param relations an array of `GtkAccessibleRelation`
             * @param values an array of `GValues`, one for each relation
             */
            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
            /**
             * Updates an array of accessible states.
             *
             * This function should be called by `GtkWidget` types whenever an accessible
             * state change must be communicated to assistive technologies.
             *
             * This function is meant to be used by language bindings.
             * @param states an array of `GtkAccessibleState`
             * @param values an array of `GValues`, one for each state
             */
            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;

            // Virtual methods

            /**
             * Retrieves the accessible parent for an accessible object.
             *
             * This function returns `NULL` for top level widgets.
             */
            vfunc_get_accessible_parent(): Accessible | null;
            /**
             * Retrieves the accessible implementation for the given `GtkAccessible`.
             */
            vfunc_get_at_context(): ATContext | null;
            /**
             * Queries the coordinates and dimensions of this accessible
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get the bounds from an ignored
             * child widget.
             */
            vfunc_get_bounds(): [boolean, number, number, number, number];
            /**
             * Retrieves the first accessible child of an accessible object.
             */
            vfunc_get_first_accessible_child(): Accessible | null;
            /**
             * Retrieves the next accessible sibling of an accessible object
             */
            vfunc_get_next_accessible_sibling(): Accessible | null;
            /**
             * Query a platform state, such as focus.
             *
             * See gtk_accessible_platform_changed().
             *
             * This functionality can be overridden by `GtkAccessible`
             * implementations, e.g. to get platform state from an ignored
             * child widget, as is the case for `GtkText` wrappers.
             * @param state platform state to query
             */
            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
        }

        export const Accessible: AccessibleNamespace & {
            new (): Accessible; // This allows `obj instanceof Accessible`
        };

        namespace AccessibleRange {
            // Constructor properties interface

            interface ConstructorProps extends Accessible.ConstructorProps {}
        }

        export interface AccessibleRangeNamespace {
            $gtype: GObject.GType<AccessibleRange>;
            prototype: AccessibleRange;
        }
        interface AccessibleRange extends Accessible {
            // Virtual methods

            /**
             * Sets the current value of the accessible range.
             *
             * This operation should behave similarly as if the user performed the
             * action.
             * @param value the value to set
             */
            vfunc_set_current_value(value: number): boolean;
        }

        export const AccessibleRange: AccessibleRangeNamespace & {
            new (): AccessibleRange; // This allows `obj instanceof AccessibleRange`
        };

        namespace AccessibleText {
            // Constructor properties interface

            interface ConstructorProps extends Accessible.ConstructorProps {}
        }

        export interface AccessibleTextNamespace {
            $gtype: GObject.GType<AccessibleText>;
            prototype: AccessibleText;
        }
        interface AccessibleText extends Accessible {
            // Methods

            /**
             * Updates the position of the caret.
             *
             * Implementations of the `GtkAccessibleText` interface should call this
             * function every time the caret has moved, in order to notify assistive
             * technologies.
             */
            update_caret_position(): void;
            /**
             * Notifies assistive technologies of a change in contents.
             *
             * Implementations of the `GtkAccessibleText` interface should call this
             * function every time their contents change as the result of an operation,
             * like an insertion or a removal.
             *
             * Note: If the change is a deletion, this function must be called *before*
             * removing the contents, if it is an insertion, it must be called *after*
             * inserting the new contents.
             * @param change the type of change in the contents
             * @param start the starting offset of the change, in characters
             * @param end the end offset of the change, in characters
             */
            update_contents(change: AccessibleTextContentChange | null, start: number, end: number): void;
            /**
             * Updates the boundary of the selection.
             *
             * Implementations of the `GtkAccessibleText` interface should call this
             * function every time the selection has moved, in order to notify assistive
             * technologies.
             */
            update_selection_bound(): void;

            // Virtual methods

            /**
             * Retrieves the text attributes inside the accessible object.
             *
             * Each attribute is composed by:
             *
             * - a range
             * - a name
             * - a value
             *
             * It is left to the implementation to determine the serialization format
             * of the value to a string.
             *
             * GTK provides support for various text attribute names and values, but
             * implementations of this interface are free to add their own attributes.
             *
             * If this function returns true, `n_ranges` will be set to a value
             * greater than or equal to one, `ranges` will be set to a newly
             * allocated array of [struct#Gtk.AccessibleTextRange].
             * @param offset the offset, in characters
             */
            vfunc_get_attributes(
                offset: number,
            ): [boolean, AccessibleTextRange[] | null, string[] | null, string[] | null];
            /**
             * Retrieves the position of the caret inside the accessible object.
             */
            vfunc_get_caret_position(): number;
            /**
             * Retrieve the current contents of the accessible object within
             * the given range.
             *
             * If `end` is `G_MAXUINT`, the end of the range is the full content
             * of the accessible object.
             * @param start the beginning of the range, in characters
             * @param end the end of the range, in characters
             */
            vfunc_get_contents(start: number, end: number): GLib.Bytes;
            /**
             * Retrieve the current contents of the accessible object starting
             * from the given offset, and using the given granularity.
             *
             * The `start` and `end` values contain the boundaries of the text.
             * @param offset the offset, in characters
             * @param granularity the granularity of the query
             */
            vfunc_get_contents_at(offset: number, granularity: AccessibleTextGranularity): [GLib.Bytes, number, number];
            /**
             * Retrieves the default text attributes inside the accessible object.
             *
             * Each attribute is composed by:
             *
             * - a name
             * - a value
             *
             * It is left to the implementation to determine the serialization format
             * of the value to a string.
             *
             * GTK provides support for various text attribute names and values, but
             * implementations of this interface are free to add their own attributes.
             */
            vfunc_get_default_attributes(): [string[] | null, string[] | null];
            /**
             * Obtains the extents of a range of text, in widget coordinates.
             * @param start the start offset, in characters
             * @param end the end offset, in characters, @extents (out caller-allocates): return location for the extents
             * @param extents
             */
            vfunc_get_extents(start: number, end: number, extents: Graphene.Rect): boolean;
            /**
             * Gets the text offset at a given point.
             * @param point a point in widget coordinates of @self
             */
            vfunc_get_offset(point: Graphene.Point): [boolean, number];
            /**
             * Retrieves the selection ranges in the accessible object.
             *
             * If this function returns true, `n_ranges` will be set to a value
             * greater than or equal to one, and `ranges` will be set to a newly
             * allocated array of [struct#Gtk.AccessibleTextRange].
             */
            vfunc_get_selection(): [boolean, AccessibleTextRange[] | null];
        }

        export const AccessibleText: AccessibleTextNamespace & {
            new (): AccessibleText; // This allows `obj instanceof AccessibleText`
        };

        namespace Actionable {
            // Constructor properties interface

            interface ConstructorProps extends Widget.ConstructorProps {
                action_name: string;
                actionName: string;
                action_target: GLib.Variant;
                actionTarget: GLib.Variant;
            }
        }

        export interface ActionableNamespace {
            $gtype: GObject.GType<Actionable>;
            prototype: Actionable;
        }
        interface Actionable extends Widget {
            // Properties

            /**
             * The name of the action with which this widget should be associated.
             */
            get action_name(): string;
            set action_name(val: string);
            /**
             * The name of the action with which this widget should be associated.
             */
            get actionName(): string;
            set actionName(val: string);
            /**
             * The target value of the actionable widget's action.
             */
            get action_target(): GLib.Variant;
            set action_target(val: GLib.Variant);
            /**
             * The target value of the actionable widget's action.
             */
            get actionTarget(): GLib.Variant;
            set actionTarget(val: GLib.Variant);

            // Methods

            /**
             * Gets the action name for `actionable`.
             * @returns the action name
             */
            get_action_name(): string | null;
            /**
             * Gets the current target value of `actionable`.
             * @returns the current target value
             */
            get_action_target_value(): GLib.Variant | null;
            /**
             * Specifies the name of the action with which this widget should be
             * associated.
             *
             * If `action_name` is %NULL then the widget will be unassociated from
             * any previous action.
             *
             * Usually this function is used when the widget is located (or will be
             * located) within the hierarchy of a `GtkApplicationWindow`.
             *
             * Names are of the form “win.save” or “app.quit” for actions on the
             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
             * associated with the window.
             * @param action_name an action name
             */
            set_action_name(action_name?: string | null): void;
            /**
             * Sets the target value of an actionable widget.
             *
             * If `target_value` is %NULL then the target value is unset.
             *
             * The target value has two purposes. First, it is used as the parameter
             * to activation of the action associated with the `GtkActionable` widget.
             * Second, it is used to determine if the widget should be rendered as
             * “active” — the widget is active if the state is equal to the given target.
             *
             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
             * with string state in a typical “radio button” situation. Each button
             * will be associated with the same action, but with a different target
             * value for that action. Clicking on a particular button will activate
             * the action with the target of that button, which will typically cause
             * the action’s state to change to that value. Since the action’s state
             * is now equal to the target value of the button, the button will now
             * be rendered as active (and the other buttons, with different targets,
             * rendered inactive).
             * @param target_value a [struct@GLib.Variant] to set as the target value
             */
            set_action_target_value(target_value?: GLib.Variant | null): void;
            /**
             * Sets the action-name and associated string target value of an
             * actionable widget.
             *
             * `detailed_action_name` is a string in the format accepted by
             * [func`Gio`.Action.parse_detailed_name].
             * @param detailed_action_name the detailed action name
             */
            set_detailed_action_name(detailed_action_name: string): void;

            // Virtual methods

            /**
             * Gets the action name for `actionable`.
             */
            vfunc_get_action_name(): string | null;
            /**
             * Gets the current target value of `actionable`.
             */
            vfunc_get_action_target_value(): GLib.Variant | null;
            /**
             * Specifies the name of the action with which this widget should be
             * associated.
             *
             * If `action_name` is %NULL then the widget will be unassociated from
             * any previous action.
             *
             * Usually this function is used when the widget is located (or will be
             * located) within the hierarchy of a `GtkApplicationWindow`.
             *
             * Names are of the form “win.save” or “app.quit” for actions on the
             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
             * associated with the window.
             * @param action_name an action name
             */
            vfunc_set_action_name(action_name?: string | null): void;
            /**
             * Sets the target value of an actionable widget.
             *
             * If `target_value` is %NULL then the target value is unset.
             *
             * The target value has two purposes. First, it is used as the parameter
             * to activation of the action associated with the `GtkActionable` widget.
             * Second, it is used to determine if the widget should be rendered as
             * “active” — the widget is active if the state is equal to the given target.
             *
             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
             * with string state in a typical “radio button” situation. Each button
             * will be associated with the same action, but with a different target
             * value for that action. Clicking on a particular button will activate
             * the action with the target of that button, which will typically cause
             * the action’s state to change to that value. Since the action’s state
             * is now equal to the target value of the button, the button will now
             * be rendered as active (and the other buttons, with different targets,
             * rendered inactive).
             * @param target_value a [struct@GLib.Variant] to set as the target value
             */
            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
        }

        export const Actionable: ActionableNamespace & {
            new (): Actionable; // This allows `obj instanceof Actionable`
        };

        namespace AppChooser {
            // Constructor properties interface

            interface ConstructorProps extends Widget.ConstructorProps {
                content_type: string;
                contentType: string;
            }
        }

        export interface AppChooserNamespace {
            $gtype: GObject.GType<AppChooser>;
            prototype: AppChooser;
        }
        interface AppChooser extends Widget {
            // Properties

            /**
             * The content type of the `GtkAppChooser` object.
             *
             * See `GContentType` for more information about content types.
             */
            get content_type(): string;
            /**
             * The content type of the `GtkAppChooser` object.
             *
             * See `GContentType` for more information about content types.
             */
            get contentType(): string;

            // Methods

            /**
             * Returns the currently selected application.
             * @returns a `GAppInfo` for the   currently selected application
             */
            get_app_info(): Gio.AppInfo | null;
            /**
             * Returns the content type for which the `GtkAppChooser`
             * shows applications.
             * @returns the content type of @self. Free with g_free()
             */
            get_content_type(): string;
            /**
             * Reloads the list of applications.
             */
            refresh(): void;
        }

        export const AppChooser: AppChooserNamespace & {
            new (): AppChooser; // This allows `obj instanceof AppChooser`
        };

        namespace Buildable {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        export interface BuildableNamespace {
            $gtype: GObject.GType<Buildable>;
            prototype: Buildable;
        }
        interface Buildable extends GObject.Object {
            // Methods

            /**
             * Gets the ID of the `buildable` object.
             *
             * `GtkBuilder` sets the name based on the ID attribute
             * of the `<object>` tag used to construct the `buildable`.
             * @returns the ID of the buildable object
             */
            get_buildable_id(): string | null;

            // Virtual methods

            /**
             * Adds a child to `buildable`. `type` is an optional string
             * describing how the child should be added.
             * @param builder a `GtkBuilder`
             * @param child child to add
             * @param type kind of child or %NULL
             */
            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
            /**
             * Similar to gtk_buildable_parser_finished() but is
             * called once for each custom tag handled by the `buildable`.
             * @param builder a `GtkBuilder`
             * @param child child object or %NULL for non-child tags
             * @param tagname the name of the tag
             * @param data user data created in custom_tag_start
             */
            vfunc_custom_finished(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called at the end of each custom element handled by
             * the buildable.
             * @param builder `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             * @param data user data that will be passed in to parser functions
             */
            vfunc_custom_tag_end(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
                data?: any | null,
            ): void;
            /**
             * Called for each unknown element under `<child>`.
             * @param builder a `GtkBuilder` used to construct this object
             * @param child child object or %NULL for non-child tags
             * @param tagname name of tag
             */
            vfunc_custom_tag_start(
                builder: Builder,
                child: GObject.Object | null,
                tagname: string,
            ): [boolean, BuildableParser, any];
            /**
             * The getter corresponding to `set_id`. Implement this
             *   if you implement `set_id`.
             */
            vfunc_get_id(): string;
            /**
             * Retrieves the internal child called `childname` of the `buildable` object.
             * @param builder a `GtkBuilder`
             * @param childname name of child
             */
            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
            /**
             * Called when a builder finishes the parsing
             *  of a UI definition. It is normally not necessary to implement this,
             *  unless you need to perform special cleanup actions. `GtkWindow` sets
             *  the `GtkWidget:visible` property here.
             * @param builder
             */
            vfunc_parser_finished(builder: Builder): void;
            /**
             * Sets a property of a buildable object.
             *  It is normally not necessary to implement this, g_object_set_property()
             *  is used by default. `GtkWindow` implements this to delay showing itself
             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
             *  interface is created.
             * @param builder
             * @param name
             * @param value
             */
            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
            /**
             * Stores the id attribute given in the `GtkBuilder` UI definition.
             *   `GtkWidget` stores the name as object data. Implement this method if your
             *   object has some notion of “ID” and it makes sense to map the XML id
             *   attribute to it.
             * @param id
             */
            vfunc_set_id(id: string): void;
        }

        export const Buildable: BuildableNamespace & {
            new (): Buildable; // This allows `obj instanceof Buildable`
        };

        namespace BuilderScope {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        export interface BuilderScopeNamespace {
            $gtype: GObject.GType<BuilderScope>;
            prototype: BuilderScope;
        }
        interface BuilderScope extends GObject.Object {
            // Virtual methods

            /**
             * Create a closure with the given arguments. See gtk_builder_create_closure()
             *   for more details on those.
             *   The C implementation will try to use dlsym() to locate the function name and then
             *   g_cclosure_new() to create a closure for the symbol.
             *   The default implementation just fails and returns %NULL.
             * @param builder
             * @param function_name
             * @param flags
             * @param object
             */
            vfunc_create_closure(
                builder: Builder,
                function_name: string,
                flags: BuilderClosureFlags,
                object: GObject.Object,
            ): GObject.Closure;
            /**
             * Try to lookup a `GType` via the given function name, specified
             *   explicitly in a GtkBuilder file, like via the "type-func" attribute in the `<object>` tag.
             *   This function is very rarely used.
             *   The C implementation will use dlsym() and call the resulting function as a `GTypeFunc`.
             *   The default implementation will fail and just return %G_TYPE_INVALID.
             * @param builder
             * @param function_name
             */
            vfunc_get_type_from_function(builder: Builder, function_name: string): GObject.GType;
            /**
             * Try to lookup a `GType` via the its name. See
             *   gtk_builder_get_type_from_name() for more details.
             *   The C implementation will use g_type_from_name() and if that fails try to guess the
             *   correct function name for registering the type and then use dlsym() to load it.
             *   The default implementation just tries g_type_from_name() and otherwise fails.
             * @param builder
             * @param type_name
             */
            vfunc_get_type_from_name(builder: Builder, type_name: string): GObject.GType;
        }

        export const BuilderScope: BuilderScopeNamespace & {
            new (): BuilderScope; // This allows `obj instanceof BuilderScope`
        };

        namespace CellEditable {
            // Constructor properties interface

            interface ConstructorProps extends Widget.ConstructorProps {
                editing_canceled: boolean;
                editingCanceled: boolean;
            }
        }

        export interface CellEditableNamespace {
            $gtype: GObject.GType<CellEditable>;
            prototype: CellEditable;
        }
        interface CellEditable extends Widget {
            // Properties

            /**
             * Indicates whether editing on the cell has been canceled.
             */
            get editing_canceled(): boolean;
            set editing_canceled(val: boolean);
            /**
             * Indicates whether editing on the cell has been canceled.
             */
            get editingCanceled(): boolean;
            set editingCanceled(val: boolean);

            // Methods

            /**
             * Emits the `GtkCellEditable::editing-done` signal.
             */
            editing_done(): void;
            /**
             * Emits the `GtkCellEditable::remove-widget` signal.
             */
            remove_widget(): void;
            /**
             * Begins editing on a `cell_editable`.
             *
             * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
             * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
             *
             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
             * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
             *
             * Note that the `cell_editable` is created on-demand for the current edit; its
             * lifetime is temporary and does not persist across other edits and/or cells.
             * @param event The `GdkEvent` that began the editing process, or   %NULL if editing was initiated programmatically
             */
            start_editing(event?: Gdk.Event | null): void;

            // Virtual methods

            /**
             * Emits the `GtkCellEditable::editing-done` signal.
             */
            vfunc_editing_done(): void;
            /**
             * Emits the `GtkCellEditable::remove-widget` signal.
             */
            vfunc_remove_widget(): void;
            /**
             * Begins editing on a `cell_editable`.
             *
             * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
             * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
             *
             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
             * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
             *
             * Note that the `cell_editable` is created on-demand for the current edit; its
             * lifetime is temporary and does not persist across other edits and/or cells.
             * @param event The `GdkEvent` that began the editing process, or   %NULL if editing was initiated programmatically
             */
            vfunc_start_editing(event?: Gdk.Event | null): void;
        }

        export const CellEditable: CellEditableNamespace & {
            new (): CellEditable; // This allows `obj instanceof CellEditable`
        };

        namespace CellLayout {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        export interface CellLayoutNamespace {
            $gtype: GObject.GType<CellLayout>;
            prototype: CellLayout;
        }
        interface CellLayout extends GObject.Object {
            // Methods

            /**
             * Adds an attribute mapping to the list in `cell_layout`.
             *
             * The `column` is the column of the model to get a value from, and the
             * `attribute` is the property on `cell` to be set from that value. So for
             * example if column 2 of the model contains strings, you could have the
             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
             * In this context "attribute" and "property" are used interchangeably.
             * @param cell a `GtkCellRenderer`
             * @param attribute a property on the renderer
             * @param column the column position on the model to get the attribute from
             */
            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
            /**
             * Unsets all the mappings on all renderers on `cell_layout` and
             * removes all renderers from `cell_layout`.
             */
            clear(): void;
            /**
             * Clears all existing attributes previously set with
             * gtk_cell_layout_set_attributes().
             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
             */
            clear_attributes(cell: CellRenderer): void;
            /**
             * Returns the underlying `GtkCellArea` which might be `cell_layout`
             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
             * is used by `cell_layout`.
             * @returns the cell area used by @cell_layout
             */
            get_area(): CellArea | null;
            /**
             * Returns the cell renderers which have been added to `cell_layout`.
             * @returns a list of cell renderers. The list, but not the renderers has   been newly allocated and should be freed with g_list_free()   when no longer needed.
             */
            get_cells(): CellRenderer[];
            /**
             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
             * `cell` is allocated no more space than it needs. Any unused space is
             * divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            pack_end(cell: CellRenderer, expand: boolean): void;
            /**
             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
             * then the `cell` is allocated no more space than it needs. Any unused space
             * is divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            pack_start(cell: CellRenderer, expand: boolean): void;
            /**
             * Re-inserts `cell` at `position`.
             *
             * Note that `cell` has already to be packed into `cell_layout`
             * for this to function properly.
             * @param cell a `GtkCellRenderer` to reorder
             * @param position new position to insert @cell at
             */
            reorder(cell: CellRenderer, position: number): void;
            /**
             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
             *
             * This function is used instead of the standard attributes mapping
             * for setting the column value, and should set the value of `cell_layout’`s
             * cell renderer(s) as appropriate.
             *
             * `func` may be %NULL to remove a previously set function.
             * @param cell a `GtkCellRenderer`
             * @param func the `GtkCellLayout`DataFunc to use
             */
            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;

            // Virtual methods

            /**
             * Adds an attribute mapping to the list in `cell_layout`.
             *
             * The `column` is the column of the model to get a value from, and the
             * `attribute` is the property on `cell` to be set from that value. So for
             * example if column 2 of the model contains strings, you could have the
             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
             * In this context "attribute" and "property" are used interchangeably.
             * @param cell a `GtkCellRenderer`
             * @param attribute a property on the renderer
             * @param column the column position on the model to get the attribute from
             */
            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
            /**
             * Unsets all the mappings on all renderers on `cell_layout` and
             * removes all renderers from `cell_layout`.
             */
            vfunc_clear(): void;
            /**
             * Clears all existing attributes previously set with
             * gtk_cell_layout_set_attributes().
             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
             */
            vfunc_clear_attributes(cell: CellRenderer): void;
            /**
             * Returns the underlying `GtkCellArea` which might be `cell_layout`
             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
             * is used by `cell_layout`.
             */
            vfunc_get_area(): CellArea | null;
            /**
             * Returns the cell renderers which have been added to `cell_layout`.
             */
            vfunc_get_cells(): CellRenderer[];
            /**
             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
             * `cell` is allocated no more space than it needs. Any unused space is
             * divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
            /**
             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
             * then the `cell` is allocated no more space than it needs. Any unused space
             * is divided evenly between cells for which `expand` is %TRUE.
             *
             * Note that reusing the same cell renderer is not supported.
             * @param cell a `GtkCellRenderer`
             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
             */
            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
            /**
             * Re-inserts `cell` at `position`.
             *
             * Note that `cell` has already to be packed into `cell_layout`
             * for this to function properly.
             * @param cell a `GtkCellRenderer` to reorder
             * @param position new position to insert @cell at
             */
            vfunc_reorder(cell: CellRenderer, position: number): void;
            /**
             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
             *
             * This function is used instead of the standard attributes mapping
             * for setting the column value, and should set the value of `cell_layout’`s
             * cell renderer(s) as appropriate.
             *
             * `func` may be %NULL to remove a previously set function.
             * @param cell a `GtkCellRenderer`
             * @param func the `GtkCellLayout`DataFunc to use
             */
            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
        }

        export const CellLayout: CellLayoutNamespace & {
            new (): CellLayout; // This allows `obj instanceof CellLayout`
        };

        namespace ColorChooser {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                rgba: Gdk.RGBA;
                use_alpha: boolean;
                useAlpha: boolean;
            }
        }

        export interface ColorChooserNamespace {
            $gtype: GObject.GType<ColorChooser>;
            prototype: ColorChooser;
        }
        interface ColorChooser extends GObject.Object {
            // Properties

            /**
             * The currently selected color, as a `GdkRGBA` struct.
             *
             * The property can be set to change the current selection
             * programmatically.
             */
            get rgba(): Gdk.RGBA;
            set rgba(val: Gdk.RGBA);
            /**
             * Whether colors may have alpha (translucency).
             *
             * When ::use-alpha is %FALSE, the `GdkRGBA` struct obtained
             * via the [property`Gtk`.ColorChooser:rgba] property will be
             * forced to have alpha == 1.
             *
             * Implementations are expected to show alpha by rendering the color
             * over a non-uniform background (like a checkerboard pattern).
             */
            get use_alpha(): boolean;
            set use_alpha(val: boolean);
            /**
             * Whether colors may have alpha (translucency).
             *
             * When ::use-alpha is %FALSE, the `GdkRGBA` struct obtained
             * via the [property`Gtk`.ColorChooser:rgba] property will be
             * forced to have alpha == 1.
             *
             * Implementations are expected to show alpha by rendering the color
             * over a non-uniform background (like a checkerboard pattern).
             */
            get useAlpha(): boolean;
            set useAlpha(val: boolean);

            // Methods

            /**
             * Adds a palette to the color chooser.
             *
             * If `orientation` is horizontal, the colors are grouped in rows,
             * with `colors_per_line` colors in each row. If `horizontal` is %FALSE,
             * the colors are grouped in columns instead.
             *
             * The default color palette of [class`Gtk`.ColorChooserWidget] has
             * 45 colors, organized in columns of 5 colors (this includes some
             * grays).
             *
             * The layout of the color chooser widget works best when the
             * palettes have 9-10 columns.
             *
             * Calling this function for the first time has the side effect
             * of removing the default color palette from the color chooser.
             *
             * If `colors` is %NULL, removes all previously added palettes.
             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should   be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
             * @param colors_per_line the number of colors to show in each row/column
             * @param colors the colors of the palette
             */
            add_palette(orientation: Orientation | null, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
            /**
             * Gets the currently-selected color.
             */
            get_rgba(): Gdk.RGBA;
            /**
             * Returns whether the color chooser shows the alpha channel.
             * @returns %TRUE if the color chooser uses the alpha channel,   %FALSE if not
             */
            get_use_alpha(): boolean;
            /**
             * Sets the color.
             * @param color the new color
             */
            set_rgba(color: Gdk.RGBA): void;
            /**
             * Sets whether or not the color chooser should use the alpha channel.
             * @param use_alpha %TRUE if color chooser should use alpha channel, %FALSE if not
             */
            set_use_alpha(use_alpha: boolean): void;

            // Virtual methods

            /**
             * Adds a palette to the color chooser.
             *
             * If `orientation` is horizontal, the colors are grouped in rows,
             * with `colors_per_line` colors in each row. If `horizontal` is %FALSE,
             * the colors are grouped in columns instead.
             *
             * The default color palette of [class`Gtk`.ColorChooserWidget] has
             * 45 colors, organized in columns of 5 colors (this includes some
             * grays).
             *
             * The layout of the color chooser widget works best when the
             * palettes have 9-10 columns.
             *
             * Calling this function for the first time has the side effect
             * of removing the default color palette from the color chooser.
             *
             * If `colors` is %NULL, removes all previously added palettes.
             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should   be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
             * @param colors_per_line the number of colors to show in each row/column
             * @param colors the colors of the palette
             */
            vfunc_add_palette(orientation: Orientation, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
            vfunc_color_activated(color: Gdk.RGBA): void;
            /**
             * Gets the currently-selected color.
             */
            vfunc_get_rgba(): Gdk.RGBA;
            /**
             * Sets the color.
             * @param color the new color
             */
            vfunc_set_rgba(color: Gdk.RGBA): void;
        }

        export const ColorChooser: ColorChooserNamespace & {
            new (): ColorChooser; // This allows `obj instanceof ColorChooser`
        };

        namespace ConstraintTarget {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        export interface ConstraintTargetNamespace {
            $gtype: GObject.GType<ConstraintTarget>;
            prototype: ConstraintTarget;
        }
        interface ConstraintTarget extends GObject.Object {}

        export const ConstraintTarget: ConstraintTargetNamespace & {
            new (): ConstraintTarget; // This allows `obj instanceof ConstraintTarget`
        };

        namespace Editable {
            // Constructor properties interface

            interface ConstructorProps extends Widget.ConstructorProps {
                cursor_position: number;
                cursorPosition: number;
                editable: boolean;
                enable_undo: boolean;
                enableUndo: boolean;
                max_width_chars: number;
                maxWidthChars: number;
                selection_bound: number;
                selectionBound: number;
                text: string;
                width_chars: number;
                widthChars: number;
                xalign: number;
            }
        }

        export interface EditableNamespace {
            $gtype: GObject.GType<Editable>;
            prototype: Editable;

            /**
             * Gets a property of the `GtkEditable` delegate for `object`.
             *
             * This is helper function that should be called in the `get_property`
             * function of your `GtkEditable` implementation, before handling your
             * own properties.
             * @param object a `GObject`
             * @param prop_id a property ID
             * @param value value to set
             * @param pspec the `GParamSpec` for the property
             */
            delegate_get_property(
                object: GObject.Object,
                prop_id: number,
                value: GObject.Value | any,
                pspec: GObject.ParamSpec,
            ): boolean;
            /**
             * Sets a property on the `GtkEditable` delegate for `object`.
             *
             * This is a helper function that should be called in the `set_property`
             * function of your `GtkEditable` implementation, before handling your
             * own properties.
             * @param object a `GObject`
             * @param prop_id a property ID
             * @param value value to set
             * @param pspec the `GParamSpec` for the property
             */
            delegate_set_property(
                object: GObject.Object,
                prop_id: number,
                value: GObject.Value | any,
                pspec: GObject.ParamSpec,
            ): boolean;
            /**
             * Overrides the `GtkEditable` properties for `class`.
             *
             * This is a helper function that should be called in class_init,
             * after installing your own properties.
             *
             * Note that your class must have "text", "cursor-position",
             * "selection-bound", "editable", "width-chars", "max-width-chars",
             * "xalign" and "enable-undo" properties for this function to work.
             *
             * To handle the properties in your set_property and get_property
             * functions, you can either use [func`Gtk`.Editable.delegate_set_property]
             * and [func`Gtk`.Editable.delegate_get_property] (if you are using
             * a delegate), or remember the `first_prop` offset and add it to the
             * values in the [enum`Gtk`.EditableProperties] enumeration to get the
             * property IDs for these properties.
             * @param object_class a `GObjectClass`
             * @param first_prop property ID to use for the first property
             */
            install_properties(object_class: typeof GObject.Object, first_prop: number): number;
            install_properties(...args: never[]): any;
        }
        interface Editable extends Widget {
            // Properties

            /**
             * The current position of the insertion cursor in chars.
             */
            get cursor_position(): number;
            /**
             * The current position of the insertion cursor in chars.
             */
            get cursorPosition(): number;
            /**
             * Whether the entry contents can be edited.
             */
            get editable(): boolean;
            set editable(val: boolean);
            /**
             * If undo/redo should be enabled for the editable.
             */
            get enable_undo(): boolean;
            set enable_undo(val: boolean);
            /**
             * If undo/redo should be enabled for the editable.
             */
            get enableUndo(): boolean;
            set enableUndo(val: boolean);
            /**
             * The desired maximum width of the entry, in characters.
             */
            get max_width_chars(): number;
            set max_width_chars(val: number);
            /**
             * The desired maximum width of the entry, in characters.
             */
            get maxWidthChars(): number;
            set maxWidthChars(val: number);
            /**
             * The position of the opposite end of the selection from the cursor in chars.
             */
            get selection_bound(): number;
            /**
             * The position of the opposite end of the selection from the cursor in chars.
             */
            get selectionBound(): number;
            /**
             * The contents of the entry.
             */
            get text(): string;
            set text(val: string);
            /**
             * Number of characters to leave space for in the entry.
             */
            get width_chars(): number;
            set width_chars(val: number);
            /**
             * Number of characters to leave space for in the entry.
             */
            get widthChars(): number;
            set widthChars(val: number);
            /**
             * The horizontal alignment, from 0 (left) to 1 (right).
             *
             * Reversed for RTL layouts.
             */
            get xalign(): number;
            set xalign(val: number);

            // Methods

            /**
             * Retrieves the accessible platform state from the editable delegate.
             *
             * This is an helper function to retrieve the accessible state for
             * `GtkEditable` interface implementations using a delegate pattern.
             *
             * You should call this function in your editable widget implementation
             * of the [vfunc`Gtk`.Accessible.get_platform_state] virtual function, for
             * instance:
             *
             * ```c
             * static void
             * accessible_interface_init (GtkAccessibleInterface *iface)
             * {
             *   iface->get_platform_state = your_editable_get_accessible_platform_state;
             * }
             *
             * static gboolean
             * your_editable_get_accessible_platform_state (GtkAccessible *accessible,
             *                                              GtkAccessiblePlatformState state)
             * {
             *   return gtk_editable_delegate_get_accessible_platform_state (GTK_EDITABLE (accessible), state);
             * }
             * ```
             *
             * Note that the widget which is the delegate *must* be a direct child of
             * this widget, otherwise your implementation of [vfunc`Gtk`.Accessible.get_platform_state]
             * might not even be called, as the platform change will originate from
             * the parent of the delegate, and, as a result, will not work properly.
             *
             * So, if you can't ensure the direct child condition, you should give the
             * delegate the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role, or you can
             * change your tree to allow this function to work.
             * @param state what kind of accessible state to retrieve
             * @returns the accessible platform state of the delegate
             */
            delegate_get_accessible_platform_state(state: AccessiblePlatformState | null): boolean;
            /**
             * Deletes the currently selected text of the editable.
             *
             * This call doesn’t do anything if there is no selected text.
             */
            delete_selection(): void;
            /**
             * Deletes a sequence of characters.
             *
             * The characters that are deleted are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters deleted are those from `start_pos` to
             * the end of the text.
             *
             * Note that the positions are specified in characters, not bytes.
             * @param start_pos start position
             * @param end_pos end position
             */
            delete_text(start_pos: number, end_pos: number): void;
            /**
             * Undoes the setup done by [method`Gtk`.Editable.init_delegate].
             *
             * This is a helper function that should be called from dispose,
             * before removing the delegate object.
             */
            finish_delegate(): void;
            /**
             * Gets the alignment of the editable.
             * @returns the alignment
             */
            get_alignment(): number;
            /**
             * Retrieves a sequence of characters.
             *
             * The characters that are retrieved are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is negative,
             * then the characters retrieved are those characters from `start_pos` to
             * the end of the text.
             *
             * Note that positions are specified in characters, not bytes.
             * @param start_pos start of text
             * @param end_pos end of text
             * @returns a pointer to the contents of the widget as a   string. This string is allocated by the `GtkEditable` implementation   and should be freed by the caller.
             */
            get_chars(start_pos: number, end_pos: number): string;
            /**
             * Gets the `GtkEditable` that `editable` is delegating its
             * implementation to.
             *
             * Typically, the delegate is a [class`Gtk`.Text] widget.
             * @returns the delegate `GtkEditable`
             */
            get_delegate(): Editable | null;
            /**
             * Retrieves whether `editable` is editable.
             * @returns %TRUE if @editable is editable.
             */
            get_editable(): boolean;
            /**
             * Gets if undo/redo actions are enabled for `editable`
             * @returns %TRUE if undo is enabled
             */
            get_enable_undo(): boolean;
            /**
             * Retrieves the desired maximum width of `editable,` in characters.
             * @returns the maximum width of the entry, in characters
             */
            get_max_width_chars(): number;
            /**
             * Retrieves the current position of the cursor relative
             * to the start of the content of the editable.
             *
             * Note that this position is in characters, not in bytes.
             * @returns the cursor position
             */
            get_position(): number;
            /**
             * Retrieves the selection bound of the editable.
             *
             * `start_pos` will be filled with the start of the selection and
             * `end_pos` with end. If no text was selected both will be identical
             * and %FALSE will be returned.
             *
             * Note that positions are specified in characters, not bytes.
             * @returns %TRUE if there is a non-empty selection, %FALSE otherwise
             */
            get_selection_bounds(): [boolean, number, number];
            /**
             * Retrieves the contents of `editable`.
             *
             * The returned string is owned by GTK and must not be modified or freed.
             * @returns a pointer to the contents of the editable
             */
            get_text(): string;
            /**
             * Gets the number of characters of space reserved
             * for the contents of the editable.
             * @returns number of chars to request space for, or negative if unset
             */
            get_width_chars(): number;
            /**
             * Sets up a delegate for `GtkEditable`.
             *
             * This is assuming that the get_delegate vfunc in the `GtkEditable`
             * interface has been set up for the `editable'`s type.
             *
             * This is a helper function that should be called in instance init,
             * after creating the delegate object.
             */
            init_delegate(): void;
            /**
             * Inserts `length` bytes of `text` into the contents of the
             * widget, at position `position`.
             *
             * Note that the position is in characters, not in bytes.
             * The function updates `position` to point after the newly
             * inserted text.
             * @param text the text to insert
             * @param length the length of the text in bytes, or -1
             * @param position location of the position text will be inserted at
             */
            insert_text(text: string, length: number, position: number): number;
            /**
             * Selects a region of text.
             *
             * The characters that are selected are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters selected are those characters from
             * `start_pos` to  the end of the text.
             *
             * Note that positions are specified in characters, not bytes.
             * @param start_pos start of region
             * @param end_pos end of region
             */
            select_region(start_pos: number, end_pos: number): void;
            /**
             * Sets the alignment for the contents of the editable.
             *
             * This controls the horizontal positioning of the contents when
             * the displayed text is shorter than the width of the editable.
             * @param xalign The horizontal alignment, from 0 (left) to 1 (right).   Reversed for RTL layouts
             */
            set_alignment(xalign: number): void;
            /**
             * Determines if the user can edit the text in the editable widget.
             * @param is_editable %TRUE if the user is allowed to edit the text   in the widget
             */
            set_editable(is_editable: boolean): void;
            /**
             * If enabled, changes to `editable` will be saved for undo/redo
             * actions.
             *
             * This results in an additional copy of text changes and are not
             * stored in secure memory. As such, undo is forcefully disabled
             * when [property`Gtk`.Text:visibility] is set to %FALSE.
             * @param enable_undo if undo/redo should be enabled
             */
            set_enable_undo(enable_undo: boolean): void;
            /**
             * Sets the desired maximum width in characters of `editable`.
             * @param n_chars the new desired maximum width, in characters
             */
            set_max_width_chars(n_chars: number): void;
            /**
             * Sets the cursor position in the editable to the given value.
             *
             * The cursor is displayed before the character with the given (base 0)
             * index in the contents of the editable. The value must be less than
             * or equal to the number of characters in the editable. A value of -1
             * indicates that the position should be set after the last character
             * of the editable. Note that `position` is in characters, not in bytes.
             * @param position the position of the cursor
             */
            set_position(position: number): void;
            /**
             * Sets the text in the editable to the given value.
             *
             * This is replacing the current contents.
             * @param text the text to set
             */
            set_text(text: string): void;
            /**
             * Changes the size request of the editable to be about the
             * right size for `n_chars` characters.
             *
             * Note that it changes the size request, the size can still
             * be affected by how you pack the widget into containers.
             * If `n_chars` is -1, the size reverts to the default size.
             * @param n_chars width in chars
             */
            set_width_chars(n_chars: number): void;

            // Virtual methods

            vfunc_changed(): void;
            /**
             * Deletes a sequence of characters.
             *
             * The characters that are deleted are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters deleted are those from `start_pos` to
             * the end of the text.
             *
             * Note that the positions are specified in characters, not bytes.
             * @param start_pos start position
             * @param end_pos end position
             */
            vfunc_delete_text(start_pos: number, end_pos: number): void;
            /**
             * Deletes a sequence of characters.
             *
             * The characters that are deleted are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters deleted are those from `start_pos` to
             * the end of the text.
             *
             * Note that the positions are specified in characters, not bytes.
             * @param start_pos start position
             * @param end_pos end position
             */
            vfunc_do_delete_text(start_pos: number, end_pos: number): void;
            /**
             * Inserts `length` bytes of `text` into the contents of the
             * widget, at position `position`.
             *
             * Note that the position is in characters, not in bytes.
             * The function updates `position` to point after the newly
             * inserted text.
             * @param text the text to insert
             * @param length the length of the text in bytes, or -1
             * @param position location of the position text will be inserted at
             */
            vfunc_do_insert_text(text: string, length: number, position: number): number;
            /**
             * Gets the `GtkEditable` that `editable` is delegating its
             * implementation to.
             *
             * Typically, the delegate is a [class`Gtk`.Text] widget.
             */
            vfunc_get_delegate(): Editable | null;
            /**
             * Retrieves the selection bound of the editable.
             *
             * `start_pos` will be filled with the start of the selection and
             * `end_pos` with end. If no text was selected both will be identical
             * and %FALSE will be returned.
             *
             * Note that positions are specified in characters, not bytes.
             */
            vfunc_get_selection_bounds(): [boolean, number, number];
            /**
             * Retrieves the contents of `editable`.
             *
             * The returned string is owned by GTK and must not be modified or freed.
             */
            vfunc_get_text(): string;
            /**
             * Inserts `length` bytes of `text` into the contents of the
             * widget, at position `position`.
             *
             * Note that the position is in characters, not in bytes.
             * The function updates `position` to point after the newly
             * inserted text.
             * @param text the text to insert
             * @param length the length of the text in bytes, or -1
             * @param position location of the position text will be inserted at
             */
            vfunc_insert_text(text: string, length: number, position: number): number;
            /**
             * Selects a region of text.
             *
             * The characters that are selected are those characters at positions
             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
             * negative, then the characters selected are those characters from
             * `start_pos` to  the end of the text.
             *
             * Note that positions are specified in characters, not bytes.
             * @param start_pos start of region
             * @param end_pos end of region
             */
            vfunc_set_selection_bounds(start_pos: number, end_pos: number): void;
        }

        export const Editable: EditableNamespace & {
            new (): Editable; // This allows `obj instanceof Editable`
        };

        namespace FileChooser {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                action: FileChooserAction;
                create_folders: boolean;
                createFolders: boolean;
                filter: FileFilter;
                filters: Gio.ListModel;
                select_multiple: boolean;
                selectMultiple: boolean;
                shortcut_folders: Gio.ListModel;
                shortcutFolders: Gio.ListModel;
            }
        }

        export interface FileChooserNamespace {
            $gtype: GObject.GType<FileChooser>;
            prototype: FileChooser;
        }
        interface FileChooser extends GObject.Object {
            // Properties

            /**
             * The type of operation that the file chooser is performing.
             */
            get action(): FileChooserAction;
            set action(val: FileChooserAction);
            /**
             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
             * will offer the user to create new folders.
             */
            get create_folders(): boolean;
            set create_folders(val: boolean);
            /**
             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
             * will offer the user to create new folders.
             */
            get createFolders(): boolean;
            set createFolders(val: boolean);
            /**
             * The current filter for selecting files that are displayed.
             */
            get filter(): FileFilter;
            set filter(val: FileFilter);
            /**
             * A `GListModel` containing the filters that have been
             * added with gtk_file_chooser_add_filter().
             *
             * The returned object should not be modified. It may
             * or may not be updated for later changes.
             */
            get filters(): Gio.ListModel;
            /**
             * Whether to allow multiple files to be selected.
             */
            get select_multiple(): boolean;
            set select_multiple(val: boolean);
            /**
             * Whether to allow multiple files to be selected.
             */
            get selectMultiple(): boolean;
            set selectMultiple(val: boolean);
            /**
             * A `GListModel` containing the shortcut folders that have been
             * added with gtk_file_chooser_add_shortcut_folder().
             *
             * The returned object should not be modified. It may
             * or may not be updated for later changes.
             */
            get shortcut_folders(): Gio.ListModel;
            /**
             * A `GListModel` containing the shortcut folders that have been
             * added with gtk_file_chooser_add_shortcut_folder().
             *
             * The returned object should not be modified. It may
             * or may not be updated for later changes.
             */
            get shortcutFolders(): Gio.ListModel;

            // Methods

            /**
             * Adds a 'choice' to the file chooser.
             *
             * This is typically implemented as a combobox or, for boolean choices,
             * as a checkbutton. You can select a value using
             * [method`Gtk`.FileChooser.set_choice] before the dialog is shown,
             * and you can obtain the user-selected value in the
             * [signal`Gtk`.Dialog::response] signal handler using
             * [method`Gtk`.FileChooser.get_choice].
             * @param id id for the added choice
             * @param label user-visible label for the added choice
             * @param options ids for the options of the choice, or %NULL for a boolean choice
             * @param option_labels user-visible labels for the options, must be the same length as @options
             */
            add_choice(id: string, label: string, options?: string[] | null, option_labels?: string[] | null): void;
            /**
             * Adds `filter` to the list of filters that the user can select between.
             *
             * When a filter is selected, only files that are passed by that
             * filter are displayed.
             *
             * Note that the `chooser` takes ownership of the filter if it is floating,
             * so you have to ref and sink it if you want to keep a reference.
             * @param filter a `GtkFileFilter`
             */
            add_filter(filter: FileFilter): void;
            /**
             * Adds a folder to be displayed with the shortcut folders
             * in a file chooser.
             * @param folder a `GFile` for the folder to add
             * @returns %TRUE if the folder could be added successfully,   %FALSE otherwise.
             */
            add_shortcut_folder(folder: Gio.File): boolean;
            /**
             * Gets the type of operation that the file chooser is performing.
             * @returns the action that the file selector is performing
             */
            get_action(): FileChooserAction;
            /**
             * Gets the currently selected option in the 'choice' with the given ID.
             * @param id the ID of the choice to get
             * @returns the ID of the currently selected option
             */
            get_choice(id: string): string | null;
            /**
             * Gets whether file chooser will offer to create new folders.
             * @returns %TRUE if the Create Folder button should be displayed.
             */
            get_create_folders(): boolean;
            /**
             * Gets the current folder of `chooser` as `GFile`.
             * @returns the `GFile` for the current folder.
             */
            get_current_folder(): Gio.File | null;
            /**
             * Gets the current name in the file selector, as entered by the user.
             *
             * This is meant to be used in save dialogs, to get the currently typed
             * filename when the file itself does not exist yet.
             * @returns The raw text from the file chooser’s “Name” entry. Free with   g_free(). Note that this string is not a full pathname or URI; it is   whatever the contents of the entry are. Note also that this string is   in UTF-8 encoding, which is not necessarily the system’s encoding for   filenames.
             */
            get_current_name(): string | null;
            /**
             * Gets the `GFile` for the currently selected file in
             * the file selector.
             *
             * If multiple files are selected, one of the files will be
             * returned at random.
             *
             * If the file chooser is in folder mode, this function returns
             * the selected folder.
             * @returns a selected `GFile`. You own the   returned file; use g_object_unref() to release it.
             */
            get_file(): Gio.File | null;
            /**
             * Lists all the selected files and subfolders in the current folder
             * of `chooser` as `GFile`.
             * @returns a list model containing a `GFile` for each   selected file and subfolder in the current folder. Free the returned   list with g_object_unref().
             */
            get_files(): Gio.ListModel;
            /**
             * Gets the current filter.
             * @returns the current filter
             */
            get_filter(): FileFilter | null;
            /**
             * Gets the current set of user-selectable filters, as a list model.
             *
             * See [method`Gtk`.FileChooser.add_filter] and
             * [method`Gtk`.FileChooser.remove_filter] for changing individual filters.
             *
             * You should not modify the returned list model. Future changes to
             * `chooser` may or may not affect the returned model.
             * @returns a `GListModel` containing the current set   of user-selectable filters.
             */
            get_filters(): Gio.ListModel;
            /**
             * Gets whether multiple files can be selected in the file
             * chooser.
             * @returns %TRUE if multiple files can be selected.
             */
            get_select_multiple(): boolean;
            /**
             * Queries the list of shortcut folders in the file chooser.
             *
             * You should not modify the returned list model. Future changes to
             * `chooser` may or may not affect the returned model.
             * @returns A list model of `GFile`s
             */
            get_shortcut_folders(): Gio.ListModel;
            /**
             * Removes a 'choice' that has been added with gtk_file_chooser_add_choice().
             * @param id the ID of the choice to remove
             */
            remove_choice(id: string): void;
            /**
             * Removes `filter` from the list of filters that the user can select between.
             * @param filter a `GtkFileFilter`
             */
            remove_filter(filter: FileFilter): void;
            /**
             * Removes a folder from the shortcut folders in a file chooser.
             * @param folder a `GFile` for the folder to remove
             * @returns %TRUE if the folder could be removed successfully,   %FALSE otherwise.
             */
            remove_shortcut_folder(folder: Gio.File): boolean;
            /**
             * Sets the type of operation that the chooser is performing.
             *
             * The user interface is adapted to suit the selected action.
             *
             * For example, an option to create a new folder might be shown
             * if the action is %GTK_FILE_CHOOSER_ACTION_SAVE but not if the
             * action is %GTK_FILE_CHOOSER_ACTION_OPEN.
             * @param action the action that the file selector is performing
             */
            set_action(action: FileChooserAction | null): void;
            /**
             * Selects an option in a 'choice' that has been added with
             * gtk_file_chooser_add_choice().
             *
             * For a boolean choice, the possible options are "true" and "false".
             * @param id the ID of the choice to set
             * @param option the ID of the option to select
             */
            set_choice(id: string, option: string): void;
            /**
             * Sets whether file chooser will offer to create new folders.
             *
             * This is only relevant if the action is not set to be
             * %GTK_FILE_CHOOSER_ACTION_OPEN.
             * @param create_folders %TRUE if the Create Folder button should be displayed
             */
            set_create_folders(create_folders: boolean): void;
            /**
             * Sets the current folder for `chooser` from a `GFile`.
             * @param file the `GFile` for the new folder
             * @returns %TRUE if the folder could be changed successfully, %FALSE   otherwise.
             */
            set_current_folder(file?: Gio.File | null): boolean;
            /**
             * Sets the current name in the file selector, as if entered
             * by the user.
             *
             * Note that the name passed in here is a UTF-8 string rather
             * than a filename. This function is meant for such uses as a
             * suggested name in a “Save As...” dialog.  You can pass
             * “Untitled.doc” or a similarly suitable suggestion for the `name`.
             *
             * If you want to preselect a particular existing file, you should
             * use [method`Gtk`.FileChooser.set_file] instead.
             *
             * Please see the documentation for those functions for an example
             * of using [method`Gtk`.FileChooser.set_current_name] as well.
             * @param name the filename to use, as a UTF-8 string
             */
            set_current_name(name: string): void;
            /**
             * Sets `file` as the current filename for the file chooser.
             *
             * This includes changing to the file’s parent folder and actually selecting
             * the file in list. If the `chooser` is in %GTK_FILE_CHOOSER_ACTION_SAVE mode,
             * the file’s base name will also appear in the dialog’s file name entry.
             *
             * If the file name isn’t in the current folder of `chooser,` then the current
             * folder of `chooser` will be changed to the folder containing `file`.
             *
             * Note that the file must exist, or nothing will be done except
             * for the directory change.
             *
             * If you are implementing a save dialog, you should use this function if
             * you already have a file name to which the user may save; for example,
             * when the user opens an existing file and then does “Save As…”. If you
             * don’t have a file name already — for example, if the user just created
             * a new file and is saving it for the first time, do not call this function.
             *
             * Instead, use something similar to this:
             *
             * ```c
             * static void
             * prepare_file_chooser (GtkFileChooser *chooser,
             *                       GFile          *existing_file)
             * {
             *   gboolean document_is_new = (existing_file == NULL);
             *
             *   if (document_is_new)
             *     {
             *       GFile *default_file_for_saving = g_file_new_for_path ("./out.txt");
             *       // the user just created a new document
             *       gtk_file_chooser_set_current_folder (chooser, default_file_for_saving, NULL);
             *       gtk_file_chooser_set_current_name (chooser, "Untitled document");
             *       g_object_unref (default_file_for_saving);
             *     }
             *   else
             *     {
             *       // the user edited an existing document
             *       gtk_file_chooser_set_file (chooser, existing_file, NULL);
             *     }
             * }
             * ```
             * @param file the `GFile` to set as current
             * @returns Not useful
             */
            set_file(file: Gio.File): boolean;
            /**
             * Sets the current filter.
             *
             * Only the files that pass the filter will be displayed.
             * If the user-selectable list of filters is non-empty, then
             * the filter should be one of the filters in that list.
             *
             * Setting the current filter when the list of filters is
             * empty is useful if you want to restrict the displayed
             * set of files without letting the user change it.
             * @param filter a `GtkFileFilter`
             */
            set_filter(filter: FileFilter): void;
            /**
             * Sets whether multiple files can be selected in the file chooser.
             *
             * This is only relevant if the action is set to be
             * %GTK_FILE_CHOOSER_ACTION_OPEN or
             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER.
             * @param select_multiple %TRUE if multiple files can be selected.
             */
            set_select_multiple(select_multiple: boolean): void;
        }

        export const FileChooser: FileChooserNamespace & {
            new (): FileChooser; // This allows `obj instanceof FileChooser`
        };

        namespace FontChooser {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                font: string;
                font_desc: Pango.FontDescription;
                fontDesc: Pango.FontDescription;
                font_features: string;
                fontFeatures: string;
                language: string;
                level: FontChooserLevel;
                preview_text: string;
                previewText: string;
                show_preview_entry: boolean;
                showPreviewEntry: boolean;
            }
        }

        export interface FontChooserNamespace {
            $gtype: GObject.GType<FontChooser>;
            prototype: FontChooser;
        }
        interface FontChooser extends GObject.Object {
            // Properties

            /**
             * The font description as a string, e.g. "Sans Italic 12".
             */
            get font(): string;
            set font(val: string);
            /**
             * The font description as a `PangoFontDescription`.
             */
            get font_desc(): Pango.FontDescription;
            set font_desc(val: Pango.FontDescription);
            /**
             * The font description as a `PangoFontDescription`.
             */
            get fontDesc(): Pango.FontDescription;
            set fontDesc(val: Pango.FontDescription);
            /**
             * The selected font features.
             *
             * The format of the string is compatible with
             * CSS and with Pango attributes.
             */
            get font_features(): string;
            /**
             * The selected font features.
             *
             * The format of the string is compatible with
             * CSS and with Pango attributes.
             */
            get fontFeatures(): string;
            /**
             * The language for which the font features were selected.
             */
            get language(): string;
            set language(val: string);
            /**
             * The level of granularity to offer for selecting fonts.
             */
            get level(): FontChooserLevel;
            set level(val: FontChooserLevel);
            /**
             * The string with which to preview the font.
             */
            get preview_text(): string;
            set preview_text(val: string);
            /**
             * The string with which to preview the font.
             */
            get previewText(): string;
            set previewText(val: string);
            /**
             * Whether to show an entry to change the preview text.
             */
            get show_preview_entry(): boolean;
            set show_preview_entry(val: boolean);
            /**
             * Whether to show an entry to change the preview text.
             */
            get showPreviewEntry(): boolean;
            set showPreviewEntry(val: boolean);

            // Methods

            /**
             * Gets the currently-selected font name.
             *
             * Note that this can be a different string than what you set with
             * [method`Gtk`.FontChooser.set_font], as the font chooser widget may
             * normalize font names and thus return a string with a different
             * structure. For example, “Helvetica Italic Bold 12” could be
             * normalized to “Helvetica Bold Italic 12”.
             *
             * Use [method`Pango`.FontDescription.equal] if you want to compare two
             * font descriptions.
             * @returns A string with the name   of the current font
             */
            get_font(): string | null;
            /**
             * Gets the currently-selected font.
             *
             * Note that this can be a different string than what you set with
             * [method`Gtk`.FontChooser.set_font], as the font chooser widget may
             * normalize font names and thus return a string with a different
             * structure. For example, “Helvetica Italic Bold 12” could be
             * normalized to “Helvetica Bold Italic 12”.
             *
             * Use [method`Pango`.FontDescription.equal] if you want to compare two
             * font descriptions.
             * @returns A `PangoFontDescription` for the   current font
             */
            get_font_desc(): Pango.FontDescription | null;
            /**
             * Gets the `PangoFontFace` representing the selected font group
             * details (i.e. family, slant, weight, width, etc).
             *
             * If the selected font is not installed, returns %NULL.
             * @returns A `PangoFontFace` representing the   selected font group details
             */
            get_font_face(): Pango.FontFace | null;
            /**
             * Gets the `PangoFontFamily` representing the selected font family.
             *
             * Font families are a collection of font faces.
             *
             * If the selected font is not installed, returns %NULL.
             * @returns A `PangoFontFamily` representing the   selected font family
             */
            get_font_family(): Pango.FontFamily | null;
            /**
             * Gets the currently-selected font features.
             *
             * The format of the returned string is compatible with the
             * [CSS font-feature-settings property](https://www.w3.org/TR/css-fonts-4/#font-rend-desc).
             * It can be passed to [func`Pango`.AttrFontFeatures.new].
             * @returns the currently selected font features
             */
            get_font_features(): string;
            /**
             * Gets the custom font map of this font chooser widget,
             * or %NULL if it does not have one.
             * @returns a `PangoFontMap`
             */
            get_font_map(): Pango.FontMap | null;
            /**
             * The selected font size.
             * @returns A n integer representing the selected font size,   or -1 if no font size is selected.
             */
            get_font_size(): number;
            /**
             * Gets the language that is used for font features.
             * @returns the currently selected language
             */
            get_language(): string;
            /**
             * Returns the current level of granularity for selecting fonts.
             * @returns the current granularity level
             */
            get_level(): FontChooserLevel;
            /**
             * Gets the text displayed in the preview area.
             * @returns the text displayed in the preview area
             */
            get_preview_text(): string;
            /**
             * Returns whether the preview entry is shown or not.
             * @returns %TRUE if the preview entry is shown or %FALSE if it is hidden.
             */
            get_show_preview_entry(): boolean;
            /**
             * Adds a filter function that decides which fonts to display
             * in the font chooser.
             * @param filter a `GtkFontFilterFunc`
             */
            set_filter_func(filter?: FontFilterFunc | null): void;
            /**
             * Sets the currently-selected font.
             * @param fontname a font name like “Helvetica 12” or “Times Bold 18”
             */
            set_font(fontname: string): void;
            /**
             * Sets the currently-selected font from `font_desc`.
             * @param font_desc a `PangoFontDescription`
             */
            set_font_desc(font_desc: Pango.FontDescription): void;
            /**
             * Sets a custom font map to use for this font chooser widget.
             *
             * A custom font map can be used to present application-specific
             * fonts instead of or in addition to the normal system fonts.
             *
             * ```c
             * FcConfig *config;
             * PangoFontMap *fontmap;
             *
             * config = FcInitLoadConfigAndFonts ();
             * FcConfigAppFontAddFile (config, my_app_font_file);
             *
             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
             *
             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
             * ```
             *
             * Note that other GTK widgets will only be able to use the
             * application-specific font if it is present in the font map they use:
             *
             * ```c
             * context = gtk_widget_get_pango_context (label);
             * pango_context_set_font_map (context, fontmap);
             * ```
             * @param fontmap a `PangoFontMap`
             */
            set_font_map(fontmap?: Pango.FontMap | null): void;
            /**
             * Sets the language to use for font features.
             * @param language a language
             */
            set_language(language: string): void;
            /**
             * Sets the desired level of granularity for selecting fonts.
             * @param level the desired level of granularity
             */
            set_level(level: FontChooserLevel | null): void;
            /**
             * Sets the text displayed in the preview area.
             *
             * The `text` is used to show how the selected font looks.
             * @param text the text to display in the preview area
             */
            set_preview_text(text: string): void;
            /**
             * Shows or hides the editable preview entry.
             * @param show_preview_entry whether to show the editable preview entry or not
             */
            set_show_preview_entry(show_preview_entry: boolean): void;

            // Virtual methods

            vfunc_font_activated(fontname: string): void;
            /**
             * Gets the `PangoFontFace` representing the selected font group
             * details (i.e. family, slant, weight, width, etc).
             *
             * If the selected font is not installed, returns %NULL.
             */
            vfunc_get_font_face(): Pango.FontFace | null;
            /**
             * Gets the `PangoFontFamily` representing the selected font family.
             *
             * Font families are a collection of font faces.
             *
             * If the selected font is not installed, returns %NULL.
             */
            vfunc_get_font_family(): Pango.FontFamily | null;
            /**
             * Gets the custom font map of this font chooser widget,
             * or %NULL if it does not have one.
             */
            vfunc_get_font_map(): Pango.FontMap | null;
            /**
             * The selected font size.
             */
            vfunc_get_font_size(): number;
            /**
             * Adds a filter function that decides which fonts to display
             * in the font chooser.
             * @param filter a `GtkFontFilterFunc`
             */
            vfunc_set_filter_func(filter?: FontFilterFunc | null): void;
            /**
             * Sets a custom font map to use for this font chooser widget.
             *
             * A custom font map can be used to present application-specific
             * fonts instead of or in addition to the normal system fonts.
             *
             * ```c
             * FcConfig *config;
             * PangoFontMap *fontmap;
             *
             * config = FcInitLoadConfigAndFonts ();
             * FcConfigAppFontAddFile (config, my_app_font_file);
             *
             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
             *
             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
             * ```
             *
             * Note that other GTK widgets will only be able to use the
             * application-specific font if it is present in the font map they use:
             *
             * ```c
             * context = gtk_widget_get_pango_context (label);
             * pango_context_set_font_map (context, fontmap);
             * ```
             * @param fontmap a `PangoFontMap`
             */
            vfunc_set_font_map(fontmap?: Pango.FontMap | null): void;
        }

        export const FontChooser: FontChooserNamespace & {
            new (): FontChooser; // This allows `obj instanceof FontChooser`
        };

        namespace Native {
            // Constructor properties interface

            interface ConstructorProps extends Widget.ConstructorProps {}
        }

        export interface NativeNamespace {
            $gtype: GObject.GType<Native>;
            prototype: Native;

            /**
             * Finds the `GtkNative` associated with the surface.
             * @param surface a `GdkSurface`
             */
            get_for_surface(surface: Gdk.Surface): Native | null;
        }
        interface Native extends Widget {
            // Methods

            /**
             * Returns the renderer that is used for this `GtkNative`.
             * @returns the renderer for @self
             */
            get_renderer(): Gsk.Renderer | null;
            /**
             * Returns the surface of this `GtkNative`.
             * @returns the surface of @self
             */
            get_surface(): Gdk.Surface | null;
            /**
             * Retrieves the surface transform of `self`.
             *
             * This is the translation from `self'`s surface coordinates into
             * `self'`s widget coordinates.
             */
            get_surface_transform(): [number, number];
            /**
             * Realizes a `GtkNative`.
             *
             * This should only be used by subclasses.
             */
            realize(): void;
            /**
             * Unrealizes a `GtkNative`.
             *
             * This should only be used by subclasses.
             */
            unrealize(): void;
        }

        export const Native: NativeNamespace & {
            new (): Native; // This allows `obj instanceof Native`
        };

        namespace Orientable {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                orientation: Orientation;
            }
        }

        export interface OrientableNamespace {
            $gtype: GObject.GType<Orientable>;
            prototype: Orientable;
        }
        interface Orientable extends GObject.Object {
            // Properties

            /**
             * The orientation of the orientable.
             */
            get orientation(): Orientation;
            set orientation(val: Orientation);

            // Methods

            /**
             * Retrieves the orientation of the `orientable`.
             * @returns the orientation of the @orientable
             */
            get_orientation(): Orientation;
            /**
             * Sets the orientation of the `orientable`.
             * @param orientation the orientable’s new orientation
             */
            set_orientation(orientation: Orientation | null): void;
        }

        export const Orientable: OrientableNamespace & {
            new (): Orientable; // This allows `obj instanceof Orientable`
        };

        namespace PrintOperationPreview {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        export interface PrintOperationPreviewNamespace {
            $gtype: GObject.GType<PrintOperationPreview>;
            prototype: PrintOperationPreview;
        }
        interface PrintOperationPreview extends GObject.Object {
            // Methods

            /**
             * Ends a preview.
             *
             * This function must be called to finish a custom print preview.
             */
            end_preview(): void;
            /**
             * Returns whether the given page is included in the set of pages that
             * have been selected for printing.
             * @param page_nr a page number
             * @returns %TRUE if the page has been selected for printing
             */
            is_selected(page_nr: number): boolean;
            /**
             * Renders a page to the preview.
             *
             * This is using the print context that was passed to the
             * [signal`Gtk`.PrintOperation::preview] handler together
             * with `preview`.
             *
             * A custom print preview should use this function to render
             * the currently selected page.
             *
             * Note that this function requires a suitable cairo context to
             * be associated with the print context.
             * @param page_nr the page to render
             */
            render_page(page_nr: number): void;

            // Virtual methods

            /**
             * Ends a preview.
             *
             * This function must be called to finish a custom print preview.
             */
            vfunc_end_preview(): void;
            vfunc_got_page_size(context: PrintContext, page_setup: PageSetup): void;
            /**
             * Returns whether the given page is included in the set of pages that
             * have been selected for printing.
             * @param page_nr a page number
             */
            vfunc_is_selected(page_nr: number): boolean;
            vfunc_ready(context: PrintContext): void;
            /**
             * Renders a page to the preview.
             *
             * This is using the print context that was passed to the
             * [signal`Gtk`.PrintOperation::preview] handler together
             * with `preview`.
             *
             * A custom print preview should use this function to render
             * the currently selected page.
             *
             * Note that this function requires a suitable cairo context to
             * be associated with the print context.
             * @param page_nr the page to render
             */
            vfunc_render_page(page_nr: number): void;
        }

        export const PrintOperationPreview: PrintOperationPreviewNamespace & {
            new (): PrintOperationPreview; // This allows `obj instanceof PrintOperationPreview`
        };

        namespace Root {
            // Constructor properties interface

            interface ConstructorProps extends Native.ConstructorProps {}
        }

        export interface RootNamespace {
            $gtype: GObject.GType<Root>;
            prototype: Root;
        }
        interface Root extends Native {
            // Methods

            /**
             * Returns the display that this `GtkRoot` is on.
             * @returns the display of @root
             */
            get_display(): Gdk.Display;
            /**
             * Retrieves the current focused widget within the root.
             *
             * Note that this is the widget that would have the focus
             * if the root is active; if the root is not focused then
             * `gtk_widget_has_focus (widget)` will be %FALSE for the
             * widget.
             * @returns the currently focused widget
             */
            get_focus(): Widget | null;
            /**
             * If `focus` is not the current focus widget, and is focusable, sets
             * it as the focus widget for the root.
             *
             * If `focus` is %NULL, unsets the focus widget for the root.
             *
             * To set the focus to a particular widget in the root, it is usually
             * more convenient to use [method`Gtk`.Widget.grab_focus] instead of
             * this function.
             * @param focus widget to be the new focus widget, or %NULL    to unset the focus widget
             */
            set_focus(focus?: Widget | null): void;
        }

        export const Root: RootNamespace & {
            new (): Root; // This allows `obj instanceof Root`
        };

        namespace Scrollable {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                hadjustment: Adjustment;
                hscroll_policy: ScrollablePolicy;
                hscrollPolicy: ScrollablePolicy;
                vadjustment: Adjustment;
                vscroll_policy: ScrollablePolicy;
                vscrollPolicy: ScrollablePolicy;
            }
        }

        export interface ScrollableNamespace {
            $gtype: GObject.GType<Scrollable>;
            prototype: Scrollable;
        }
        interface Scrollable extends GObject.Object {
            // Properties

            /**
             * Horizontal `GtkAdjustment` of the scrollable widget.
             *
             * This adjustment is shared between the scrollable widget and its parent.
             */
            get hadjustment(): Adjustment;
            set hadjustment(val: Adjustment);
            /**
             * Determines when horizontal scrolling should start.
             */
            get hscroll_policy(): ScrollablePolicy;
            set hscroll_policy(val: ScrollablePolicy);
            /**
             * Determines when horizontal scrolling should start.
             */
            get hscrollPolicy(): ScrollablePolicy;
            set hscrollPolicy(val: ScrollablePolicy);
            /**
             * Vertical `GtkAdjustment` of the scrollable widget.
             *
             * This adjustment is shared between the scrollable widget and its parent.
             */
            get vadjustment(): Adjustment;
            set vadjustment(val: Adjustment);
            /**
             * Determines when vertical scrolling should start.
             */
            get vscroll_policy(): ScrollablePolicy;
            set vscroll_policy(val: ScrollablePolicy);
            /**
             * Determines when vertical scrolling should start.
             */
            get vscrollPolicy(): ScrollablePolicy;
            set vscrollPolicy(val: ScrollablePolicy);

            // Methods

            /**
             * Returns the size of a non-scrolling border around the
             * outside of the scrollable.
             *
             * An example for this would be treeview headers. GTK can use
             * this information to display overlaid graphics, like the
             * overshoot indication, at the right position.
             * @returns %TRUE if @border has been set
             */
            get_border(): [boolean, Border];
            /**
             * Retrieves the `GtkAdjustment` used for horizontal scrolling.
             * @returns horizontal `GtkAdjustment`.
             */
            get_hadjustment(): Adjustment | null;
            /**
             * Gets the horizontal `GtkScrollablePolicy`.
             * @returns The horizontal `GtkScrollablePolicy`.
             */
            get_hscroll_policy(): ScrollablePolicy;
            /**
             * Retrieves the `GtkAdjustment` used for vertical scrolling.
             * @returns vertical `GtkAdjustment`.
             */
            get_vadjustment(): Adjustment | null;
            /**
             * Gets the vertical `GtkScrollablePolicy`.
             * @returns The vertical `GtkScrollablePolicy`.
             */
            get_vscroll_policy(): ScrollablePolicy;
            /**
             * Sets the horizontal adjustment of the `GtkScrollable`.
             * @param hadjustment a `GtkAdjustment`
             */
            set_hadjustment(hadjustment?: Adjustment | null): void;
            /**
             * Sets the `GtkScrollablePolicy`.
             *
             * The policy determines whether horizontal scrolling should start
             * below the minimum width or below the natural width.
             * @param policy the horizontal `GtkScrollablePolicy`
             */
            set_hscroll_policy(policy: ScrollablePolicy | null): void;
            /**
             * Sets the vertical adjustment of the `GtkScrollable`.
             * @param vadjustment a `GtkAdjustment`
             */
            set_vadjustment(vadjustment?: Adjustment | null): void;
            /**
             * Sets the `GtkScrollablePolicy`.
             *
             * The policy determines whether vertical scrolling should start
             * below the minimum height or below the natural height.
             * @param policy the vertical `GtkScrollablePolicy`
             */
            set_vscroll_policy(policy: ScrollablePolicy | null): void;

            // Virtual methods

            /**
             * Returns the size of a non-scrolling border around the
             * outside of the scrollable.
             *
             * An example for this would be treeview headers. GTK can use
             * this information to display overlaid graphics, like the
             * overshoot indication, at the right position.
             */
            vfunc_get_border(): [boolean, Border];
        }

        export const Scrollable: ScrollableNamespace & {
            new (): Scrollable; // This allows `obj instanceof Scrollable`
        };

        namespace SectionModel {
            // Constructor properties interface

            interface ConstructorProps<A extends GObject.Object = GObject.Object>
                extends Gio.ListModel.ConstructorProps<A> {}
        }

        export interface SectionModelNamespace {
            $gtype: GObject.GType<SectionModel>;
            prototype: SectionModel;
        }
        interface SectionModel<A extends GObject.Object = GObject.Object> extends Gio.ListModel {
            // Methods

            /**
             * Query the section that covers the given position. The number of
             * items in the section can be computed by `out_end - out_start`.
             *
             * If the position is larger than the number of items, a single
             * range from n_items to G_MAXUINT will be returned.
             * @param position the position of the item to query
             */
            get_section(position: number): [number, number];
            /**
             * This function emits the [signal`Gtk`.SectionModel::sections-changed]
             * signal to notify about changes to sections.
             *
             * It must cover all positions that used to be a section start or that
             * are now a section start. It does not have to cover all positions for
             * which the section has changed.
             *
             * The [signal`Gio`.ListModel::items-changed] implies the effect of the
             * [signal`Gtk`.SectionModel::sections-changed] signal for all the items
             * it covers.
             *
             * It is recommended that when changes to the items cause section changes
             * in a larger range, that the larger range is included in the emission
             * of the [signal`Gio`.ListModel::items-changed] instead of emitting
             * two signals.
             * @param position the first changed item
             * @param n_items the number of changed items
             */
            sections_changed(position: number, n_items: number): void;

            // Virtual methods

            /**
             * Query the section that covers the given position. The number of
             * items in the section can be computed by `out_end - out_start`.
             *
             * If the position is larger than the number of items, a single
             * range from n_items to G_MAXUINT will be returned.
             * @param position the position of the item to query
             */
            vfunc_get_section(position: number): [number, number];
        }

        export const SectionModel: SectionModelNamespace & {
            new (): SectionModel; // This allows `obj instanceof SectionModel`
        };

        namespace SelectionModel {
            // Constructor properties interface

            interface ConstructorProps<A extends GObject.Object = GObject.Object>
                extends Gio.ListModel.ConstructorProps<A> {}
        }

        export interface SelectionModelNamespace {
            $gtype: GObject.GType<SelectionModel>;
            prototype: SelectionModel;
        }
        interface SelectionModel<A extends GObject.Object = GObject.Object> extends Gio.ListModel {
            // Methods

            /**
             * Gets the set containing all currently selected items in the model.
             *
             * This function may be slow, so if you are only interested in single item,
             * consider using [method`Gtk`.SelectionModel.is_selected] or if you are only
             * interested in a few, consider [method`Gtk`.SelectionModel.get_selection_in_range].
             * @returns a `GtkBitset` containing all the values currently   selected in @model. If no items are selected, the bitset is empty.   The bitset must not be modified.
             */
            get_selection(): Bitset;
            /**
             * Gets the set of selected items in a range.
             *
             * This function is an optimization for
             * [method`Gtk`.SelectionModel.get_selection] when you are only
             * interested in part of the model's selected state. A common use
             * case is in response to the [signal`Gtk`.SelectionModel::selection-changed]
             * signal.
             * @param position start of the queried range
             * @param n_items number of items in the queried range
             * @returns A `GtkBitset` that matches the selection state   for the given range with all other values being undefined.   The bitset must not be modified.
             */
            get_selection_in_range(position: number, n_items: number): Bitset;
            /**
             * Checks if the given item is selected.
             * @param position the position of the item to query
             * @returns %TRUE if the item is selected
             */
            is_selected(position: number): boolean;
            /**
             * Requests to select all items in the model.
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items are now selected.
             */
            select_all(): boolean;
            /**
             * Requests to select an item in the model.
             * @param position the position of the item to select
             * @param unselect_rest whether previously selected items should be unselected
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the item was selected.
             */
            select_item(position: number, unselect_rest: boolean): boolean;
            /**
             * Requests to select a range of items in the model.
             * @param position the first item to select
             * @param n_items the number of items to select
             * @param unselect_rest whether previously selected items should be unselected
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the range was selected.
             */
            select_range(position: number, n_items: number, unselect_rest: boolean): boolean;
            /**
             * Helper function for implementations of `GtkSelectionModel`.
             *
             * Call this when the selection changes to emit the
             * [signal`Gtk`.SelectionModel::selection-changed] signal.
             * @param position the first changed item
             * @param n_items the number of changed items
             */
            selection_changed(position: number, n_items: number): void;
            /**
             * Make selection changes.
             *
             * This is the most advanced selection updating method that allows
             * the most fine-grained control over selection changes. If you can,
             * you should try the simpler versions, as implementations are more
             * likely to implement support for those.
             *
             * Requests that the selection state of all positions set in `mask`
             * be updated to the respective value in the `selected` bitmask.
             *
             * In pseudocode, it would look something like this:
             *
             * ```c
             * for (i = 0; i < n_items; i++)
             *   {
             *     // don't change values not in the mask
             *     if (!gtk_bitset_contains (mask, i))
             *       continue;
             *
             *     if (gtk_bitset_contains (selected, i))
             *       select_item (i);
             *     else
             *       unselect_item (i);
             *   }
             *
             * gtk_selection_model_selection_changed (model,
             *                                        first_changed_item,
             *                                        n_changed_items);
             * ```
             *
             * `mask` and `selected` must not be modified. They may refer to the
             * same bitset, which would mean that every item in the set should
             * be selected.
             * @param selected bitmask specifying if items should be selected or unselected
             * @param mask bitmask specifying which items should be updated
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items were updated according   to the inputs.
             */
            set_selection(selected: Bitset, mask: Bitset): boolean;
            /**
             * Requests to unselect all items in the model.
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items are now unselected.
             */
            unselect_all(): boolean;
            /**
             * Requests to unselect an item in the model.
             * @param position the position of the item to unselect
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the item was unselected.
             */
            unselect_item(position: number): boolean;
            /**
             * Requests to unselect a range of items in the model.
             * @param position the first item to unselect
             * @param n_items the number of items to unselect
             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the range was unselected.
             */
            unselect_range(position: number, n_items: number): boolean;

            // Virtual methods

            /**
             * Gets the set of selected items in a range.
             *
             * This function is an optimization for
             * [method`Gtk`.SelectionModel.get_selection] when you are only
             * interested in part of the model's selected state. A common use
             * case is in response to the [signal`Gtk`.SelectionModel::selection-changed]
             * signal.
             * @param position start of the queried range
             * @param n_items number of items in the queried range
             */
            vfunc_get_selection_in_range(position: number, n_items: number): Bitset;
            /**
             * Checks if the given item is selected.
             * @param position the position of the item to query
             */
            vfunc_is_selected(position: number): boolean;
            /**
             * Requests to select all items in the model.
             */
            vfunc_select_all(): boolean;
            /**
             * Requests to select an item in the model.
             * @param position the position of the item to select
             * @param unselect_rest whether previously selected items should be unselected
             */
            vfunc_select_item(position: number, unselect_rest: boolean): boolean;
            /**
             * Requests to select a range of items in the model.
             * @param position the first item to select
             * @param n_items the number of items to select
             * @param unselect_rest whether previously selected items should be unselected
             */
            vfunc_select_range(position: number, n_items: number, unselect_rest: boolean): boolean;
            /**
             * Make selection changes.
             *
             * This is the most advanced selection updating method that allows
             * the most fine-grained control over selection changes. If you can,
             * you should try the simpler versions, as implementations are more
             * likely to implement support for those.
             *
             * Requests that the selection state of all positions set in `mask`
             * be updated to the respective value in the `selected` bitmask.
             *
             * In pseudocode, it would look something like this:
             *
             * ```c
             * for (i = 0; i < n_items; i++)
             *   {
             *     // don't change values not in the mask
             *     if (!gtk_bitset_contains (mask, i))
             *       continue;
             *
             *     if (gtk_bitset_contains (selected, i))
             *       select_item (i);
             *     else
             *       unselect_item (i);
             *   }
             *
             * gtk_selection_model_selection_changed (model,
             *                                        first_changed_item,
             *                                        n_changed_items);
             * ```
             *
             * `mask` and `selected` must not be modified. They may refer to the
             * same bitset, which would mean that every item in the set should
             * be selected.
             * @param selected bitmask specifying if items should be selected or unselected
             * @param mask bitmask specifying which items should be updated
             */
            vfunc_set_selection(selected: Bitset, mask: Bitset): boolean;
            /**
             * Requests to unselect all items in the model.
             */
            vfunc_unselect_all(): boolean;
            /**
             * Requests to unselect an item in the model.
             * @param position the position of the item to unselect
             */
            vfunc_unselect_item(position: number): boolean;
            /**
             * Requests to unselect a range of items in the model.
             * @param position the first item to unselect
             * @param n_items the number of items to unselect
             */
            vfunc_unselect_range(position: number, n_items: number): boolean;
        }

        export const SelectionModel: SelectionModelNamespace & {
            new (): SelectionModel; // This allows `obj instanceof SelectionModel`
        };

        namespace ShortcutManager {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        export interface ShortcutManagerNamespace {
            $gtype: GObject.GType<ShortcutManager>;
            prototype: ShortcutManager;
        }
        interface ShortcutManager extends GObject.Object {
            // Virtual methods

            /**
             * Add a `GtkShortcutController` to be managed.
             * @param controller
             */
            vfunc_add_controller(controller: ShortcutController): void;
            /**
             * Remove a `GtkShortcutController` that had previously
             *   been added
             * @param controller
             */
            vfunc_remove_controller(controller: ShortcutController): void;
        }

        export const ShortcutManager: ShortcutManagerNamespace & {
            new (): ShortcutManager; // This allows `obj instanceof ShortcutManager`
        };

        namespace StyleProvider {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        export interface StyleProviderNamespace {
            $gtype: GObject.GType<StyleProvider>;
            prototype: StyleProvider;
        }
        interface StyleProvider extends GObject.Object {}

        export const StyleProvider: StyleProviderNamespace & {
            new (): StyleProvider; // This allows `obj instanceof StyleProvider`
        };

        namespace SymbolicPaintable {
            // Constructor properties interface

            interface ConstructorProps extends Gdk.Paintable.ConstructorProps {}
        }

        export interface SymbolicPaintableNamespace {
            $gtype: GObject.GType<SymbolicPaintable>;
            prototype: SymbolicPaintable;
        }
        interface SymbolicPaintable extends Gdk.Paintable {
            // Methods

            /**
             * Snapshots the paintable with the given colors.
             *
             * If less than 4 colors are provided, GTK will pad the array with default
             * colors.
             * @param snapshot a `GdkSnapshot` to snapshot to
             * @param width width to snapshot in
             * @param height height to snapshot in
             * @param colors a pointer to an array of colors
             */
            snapshot_symbolic(snapshot: Gdk.Snapshot, width: number, height: number, colors: Gdk.RGBA[]): void;

            // Virtual methods

            /**
             * Snapshots the paintable with the given colors.
             *
             * If less than 4 colors are provided, GTK will pad the array with default
             * colors.
             * @param snapshot a `GdkSnapshot` to snapshot to
             * @param width width to snapshot in
             * @param height height to snapshot in
             * @param colors a pointer to an array of colors
             */
            vfunc_snapshot_symbolic(snapshot: Gdk.Snapshot, width: number, height: number, colors: Gdk.RGBA[]): void;
        }

        export const SymbolicPaintable: SymbolicPaintableNamespace & {
            new (): SymbolicPaintable; // This allows `obj instanceof SymbolicPaintable`
        };

        namespace TreeDragDest {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        export interface TreeDragDestNamespace {
            $gtype: GObject.GType<TreeDragDest>;
            prototype: TreeDragDest;
        }
        interface TreeDragDest extends GObject.Object {
            // Methods

            /**
             * Asks the `GtkTreeDragDest` to insert a row before the path `dest,`
             * deriving the contents of the row from `value`. If `dest` is
             * outside the tree so that inserting before it is impossible, %FALSE
             * will be returned. Also, %FALSE may be returned if the new row is
             * not created for some model-specific reason.  Should robustly handle
             * a `dest` no longer found in the model!
             * @param dest row to drop in front of
             * @param value data to drop
             * @returns whether a new row was created before position @dest
             */
            drag_data_received(dest: TreePath, value: GObject.Value | any): boolean;
            /**
             * Determines whether a drop is possible before the given `dest_path,`
             * at the same depth as `dest_path`. i.e., can we drop the data in
             * `value` at that location. `dest_path` does not have to
             * exist; the return value will almost certainly be %FALSE if the
             * parent of `dest_path` doesn’t exist, though.
             * @param dest_path destination row
             * @param value the data being dropped
             * @returns %TRUE if a drop is possible before @dest_path
             */
            row_drop_possible(dest_path: TreePath, value: GObject.Value | any): boolean;

            // Virtual methods

            /**
             * Asks the `GtkTreeDragDest` to insert a row before the path `dest,`
             * deriving the contents of the row from `value`. If `dest` is
             * outside the tree so that inserting before it is impossible, %FALSE
             * will be returned. Also, %FALSE may be returned if the new row is
             * not created for some model-specific reason.  Should robustly handle
             * a `dest` no longer found in the model!
             * @param dest row to drop in front of
             * @param value data to drop
             */
            vfunc_drag_data_received(dest: TreePath, value: GObject.Value | any): boolean;
            /**
             * Determines whether a drop is possible before the given `dest_path,`
             * at the same depth as `dest_path`. i.e., can we drop the data in
             * `value` at that location. `dest_path` does not have to
             * exist; the return value will almost certainly be %FALSE if the
             * parent of `dest_path` doesn’t exist, though.
             * @param dest_path destination row
             * @param value the data being dropped
             */
            vfunc_row_drop_possible(dest_path: TreePath, value: GObject.Value | any): boolean;
        }

        export const TreeDragDest: TreeDragDestNamespace & {
            new (): TreeDragDest; // This allows `obj instanceof TreeDragDest`
        };

        namespace TreeDragSource {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        export interface TreeDragSourceNamespace {
            $gtype: GObject.GType<TreeDragSource>;
            prototype: TreeDragSource;
        }
        interface TreeDragSource extends GObject.Object {
            // Methods

            /**
             * Asks the `GtkTreeDragSource` to delete the row at `path,` because
             * it was moved somewhere else via drag-and-drop. Returns %FALSE
             * if the deletion fails because `path` no longer exists, or for
             * some model-specific reason. Should robustly handle a `path` no
             * longer found in the model!
             * @param path row that was being dragged
             * @returns %TRUE if the row was successfully deleted
             */
            drag_data_delete(path: TreePath): boolean;
            /**
             * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
             * the row at `path`. Should robustly handle a `path` no
             * longer found in the model!
             * @param path row that was dragged
             * @returns a `GdkContentProvider` for the    given @path
             */
            drag_data_get(path: TreePath): Gdk.ContentProvider | null;
            /**
             * Asks the `GtkTreeDragSource` whether a particular row can be used as
             * the source of a DND operation. If the source doesn’t implement
             * this interface, the row is assumed draggable.
             * @param path row on which user is initiating a drag
             * @returns %TRUE if the row can be dragged
             */
            row_draggable(path: TreePath): boolean;

            // Virtual methods

            /**
             * Asks the `GtkTreeDragSource` to delete the row at `path,` because
             * it was moved somewhere else via drag-and-drop. Returns %FALSE
             * if the deletion fails because `path` no longer exists, or for
             * some model-specific reason. Should robustly handle a `path` no
             * longer found in the model!
             * @param path row that was being dragged
             */
            vfunc_drag_data_delete(path: TreePath): boolean;
            /**
             * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
             * the row at `path`. Should robustly handle a `path` no
             * longer found in the model!
             * @param path row that was dragged
             */
            vfunc_drag_data_get(path: TreePath): Gdk.ContentProvider | null;
            /**
             * Asks the `GtkTreeDragSource` whether a particular row can be used as
             * the source of a DND operation. If the source doesn’t implement
             * this interface, the row is assumed draggable.
             * @param path row on which user is initiating a drag
             */
            vfunc_row_draggable(path: TreePath): boolean;
        }

        export const TreeDragSource: TreeDragSourceNamespace & {
            new (): TreeDragSource; // This allows `obj instanceof TreeDragSource`
        };

        namespace TreeModel {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        export interface TreeModelNamespace {
            $gtype: GObject.GType<TreeModel>;
            prototype: TreeModel;
        }
        interface TreeModel extends GObject.Object {
            // Methods

            /**
             * Creates a new `GtkTreeModel`, with `child_model` as the child_model
             * and `root` as the virtual root.
             * @param root A `GtkTreePath`
             * @returns A new `GtkTreeModel`.
             */
            filter_new(root?: TreePath | null): TreeModel;
            /**
             * Calls `func` on each node in model in a depth-first fashion.
             *
             * If `func` returns %TRUE, then the tree ceases to be walked,
             * and gtk_tree_model_foreach() returns.
             * @param func a function to be called on each row
             */
            foreach(func: TreeModelForeachFunc): void;
            /**
             * Returns the type of the column.
             * @param index_ the column index
             * @returns the type of the column
             */
            get_column_type(index_: number): GObject.GType;
            /**
             * Returns a set of flags supported by this interface.
             *
             * The flags are a bitwise combination of `GtkTreeModel`Flags.
             * The flags supported should not change during the lifetime
             * of the `tree_model`.
             * @returns the flags supported by this interface
             */
            get_flags(): TreeModelFlags;
            /**
             * Sets `iter` to a valid iterator pointing to `path`.
             *
             * If `path` does not exist, `iter` is set to an invalid
             * iterator and %FALSE is returned.
             * @param path the `GtkTreePath`
             * @returns %TRUE, if @iter was set
             */
            get_iter(path: TreePath): [boolean, TreeIter];
            /**
             * Initializes `iter` with the first iterator in the tree
             * (the one at the path "0").
             *
             * Returns %FALSE if the tree is empty, %TRUE otherwise.
             * @returns %TRUE, if @iter was set
             */
            get_iter_first(): [boolean, TreeIter];
            /**
             * Sets `iter` to a valid iterator pointing to `path_string,` if it
             * exists.
             *
             * Otherwise, `iter` is left invalid and %FALSE is returned.
             * @param path_string a string representation of a `GtkTreePath`
             * @returns %TRUE, if @iter was set
             */
            get_iter_from_string(path_string: string): [boolean, TreeIter];
            /**
             * Returns the number of columns supported by `tree_model`.
             * @returns the number of columns
             */
            get_n_columns(): number;
            /**
             * Returns a newly-created `GtkTreePath` referenced by `iter`.
             *
             * This path should be freed with gtk_tree_path_free().
             * @param iter the `GtkTreeIter`
             * @returns a newly-created `GtkTreePath`
             */
            get_path(iter: TreeIter): TreePath;
            /**
             * Generates a string representation of the iter.
             *
             * This string is a “:” separated list of numbers.
             * For example, “4:10:0:3” would be an acceptable
             * return value for this string.
             * @param iter a `GtkTreeIter`
             * @returns a newly-allocated string
             */
            get_string_from_iter(iter: TreeIter): string | null;
            /**
             * Initializes and sets `value` to that at `column`.
             *
             * When done with `value,` g_value_unset() needs to be called
             * to free any allocated memory.
             * @param iter the `GtkTreeIter`
             * @param column the column to lookup the value at
             */
            get_value(iter: TreeIter, column: number): unknown;
            /**
             * Sets `iter` to point to the first child of `parent`.
             *
             * If `parent` has no children, %FALSE is returned and `iter` is
             * set to be invalid. `parent` will remain a valid node after this
             * function has been called.
             *
             * If `parent` is %NULL returns the first node, equivalent to
             * `gtk_tree_model_get_iter_first (tree_model, iter);`
             * @param parent the `GtkTreeIter`
             * @returns %TRUE, if @iter has been set to the first child
             */
            iter_children(parent?: TreeIter | null): [boolean, TreeIter];
            /**
             * Returns %TRUE if `iter` has children, %FALSE otherwise.
             * @param iter the `GtkTreeIter` to test for children
             * @returns %TRUE if @iter has children
             */
            iter_has_child(iter: TreeIter): boolean;
            /**
             * Returns the number of children that `iter` has.
             *
             * As a special case, if `iter` is %NULL, then the number
             * of toplevel nodes is returned.
             * @param iter the `GtkTreeIter`
             * @returns the number of children of @iter
             */
            iter_n_children(iter?: TreeIter | null): number;
            /**
             * Sets `iter` to point to the node following it at the current level.
             *
             * If there is no next `iter,` %FALSE is returned and `iter` is set
             * to be invalid.
             * @param iter the `GtkTreeIter`
             * @returns %TRUE if @iter has been changed to the next node
             */
            iter_next(iter: TreeIter): boolean;
            /**
             * Sets `iter` to be the child of `parent,` using the given index.
             *
             * The first index is 0. If `n` is too big, or `parent` has no children,
             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
             * will remain a valid node after this function has been called. As a
             * special case, if `parent` is %NULL, then the `n-th` root node
             * is set.
             * @param parent the `GtkTreeIter` to get the child from
             * @param n the index of the desired child
             * @returns %TRUE, if @parent has an @n-th child
             */
            iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
            /**
             * Sets `iter` to be the parent of `child`.
             *
             * If `child` is at the toplevel, and doesn’t have a parent, then
             * `iter` is set to an invalid iterator and %FALSE is returned.
             * `child` will remain a valid node after this function has been
             * called.
             *
             * `iter` will be initialized before the lookup is performed, so `child`
             * and `iter` cannot point to the same memory location.
             * @param child the `GtkTreeIter`
             * @returns %TRUE, if @iter is set to the parent of @child
             */
            iter_parent(child: TreeIter): [boolean, TreeIter];
            /**
             * Sets `iter` to point to the previous node at the current level.
             *
             * If there is no previous `iter,` %FALSE is returned and `iter` is
             * set to be invalid.
             * @param iter the `GtkTreeIter`
             * @returns %TRUE if @iter has been changed to the previous node
             */
            iter_previous(iter: TreeIter): boolean;
            /**
             * Lets the tree ref the node.
             *
             * This is an optional method for models to implement.
             * To be more specific, models may ignore this call as it exists
             * primarily for performance reasons.
             *
             * This function is primarily meant as a way for views to let
             * caching models know when nodes are being displayed (and hence,
             * whether or not to cache that node). Being displayed means a node
             * is in an expanded branch, regardless of whether the node is currently
             * visible in the viewport. For example, a file-system based model
             * would not want to keep the entire file-hierarchy in memory,
             * just the sections that are currently being displayed by
             * every current view.
             *
             * A model should be expected to be able to get an iter independent
             * of its reffed state.
             * @param iter the `GtkTreeIter`
             */
            ref_node(iter: TreeIter): void;
            /**
             * Emits the ::row-changed signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-changed].
             * @param path a `GtkTreePath` pointing to the changed row
             * @param iter a valid `GtkTreeIter` pointing to the changed row
             */
            row_changed(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::row-deleted signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-deleted].
             *
             * This should be called by models after a row has been removed.
             * The location pointed to by `path` should be the location that
             * the row previously was at. It may not be a valid location anymore.
             *
             * Nodes that are deleted are not unreffed, this means that any
             * outstanding references on the deleted node should not be released.
             * @param path a `GtkTreePath` pointing to the previous location of   the deleted row
             */
            row_deleted(path: TreePath): void;
            /**
             * Emits the ::row-has-child-toggled signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-has-child-toggled].
             *
             * This should be called by models after the child
             * state of a node changes.
             * @param path a `GtkTreePath` pointing to the changed row
             * @param iter a valid `GtkTreeIter` pointing to the changed row
             */
            row_has_child_toggled(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::row-inserted signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-inserted].
             * @param path a `GtkTreePath` pointing to the inserted row
             * @param iter a valid `GtkTreeIter` pointing to the inserted row
             */
            row_inserted(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::rows-reordered signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::rows-reordered].
             *
             * This should be called by models when their rows have been
             * reordered.
             * @param path a `GtkTreePath` pointing to the tree node whose children   have been reordered
             * @param iter a valid `GtkTreeIter` pointing to the node   whose children have been reordered, or %NULL if the depth   of @path is 0
             * @param new_order an array of integers   mapping the current position of each child to its old   position before the re-ordering,   i.e. @new_order`[newpos] = oldpos`
             */
            rows_reordered(path: TreePath, iter: TreeIter | null, new_order: number[]): void;
            /**
             * Lets the tree unref the node.
             *
             * This is an optional method for models to implement.
             * To be more specific, models may ignore this call as it exists
             * primarily for performance reasons. For more information on what
             * this means, see gtk_tree_model_ref_node().
             *
             * Please note that nodes that are deleted are not unreffed.
             * @param iter the `GtkTreeIter`
             */
            unref_node(iter: TreeIter): void;

            // Virtual methods

            /**
             * Returns the type of the column.
             * @param index_ the column index
             */
            vfunc_get_column_type(index_: number): GObject.GType;
            /**
             * Returns a set of flags supported by this interface.
             *
             * The flags are a bitwise combination of `GtkTreeModel`Flags.
             * The flags supported should not change during the lifetime
             * of the `tree_model`.
             */
            vfunc_get_flags(): TreeModelFlags;
            /**
             * Sets `iter` to a valid iterator pointing to `path`.
             *
             * If `path` does not exist, `iter` is set to an invalid
             * iterator and %FALSE is returned.
             * @param path the `GtkTreePath`
             */
            vfunc_get_iter(path: TreePath): [boolean, TreeIter];
            /**
             * Returns the number of columns supported by `tree_model`.
             */
            vfunc_get_n_columns(): number;
            /**
             * Returns a newly-created `GtkTreePath` referenced by `iter`.
             *
             * This path should be freed with gtk_tree_path_free().
             * @param iter the `GtkTreeIter`
             */
            vfunc_get_path(iter: TreeIter): TreePath;
            /**
             * Initializes and sets `value` to that at `column`.
             *
             * When done with `value,` g_value_unset() needs to be called
             * to free any allocated memory.
             * @param iter the `GtkTreeIter`
             * @param column the column to lookup the value at
             */
            vfunc_get_value(iter: TreeIter, column: number): unknown;
            /**
             * Sets `iter` to point to the first child of `parent`.
             *
             * If `parent` has no children, %FALSE is returned and `iter` is
             * set to be invalid. `parent` will remain a valid node after this
             * function has been called.
             *
             * If `parent` is %NULL returns the first node, equivalent to
             * `gtk_tree_model_get_iter_first (tree_model, iter);`
             * @param parent the `GtkTreeIter`
             */
            vfunc_iter_children(parent?: TreeIter | null): [boolean, TreeIter];
            /**
             * Returns %TRUE if `iter` has children, %FALSE otherwise.
             * @param iter the `GtkTreeIter` to test for children
             */
            vfunc_iter_has_child(iter: TreeIter): boolean;
            /**
             * Returns the number of children that `iter` has.
             *
             * As a special case, if `iter` is %NULL, then the number
             * of toplevel nodes is returned.
             * @param iter the `GtkTreeIter`
             */
            vfunc_iter_n_children(iter?: TreeIter | null): number;
            /**
             * Sets `iter` to point to the node following it at the current level.
             *
             * If there is no next `iter,` %FALSE is returned and `iter` is set
             * to be invalid.
             * @param iter the `GtkTreeIter`
             */
            vfunc_iter_next(iter: TreeIter): boolean;
            /**
             * Sets `iter` to be the child of `parent,` using the given index.
             *
             * The first index is 0. If `n` is too big, or `parent` has no children,
             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
             * will remain a valid node after this function has been called. As a
             * special case, if `parent` is %NULL, then the `n-th` root node
             * is set.
             * @param parent the `GtkTreeIter` to get the child from
             * @param n the index of the desired child
             */
            vfunc_iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
            /**
             * Sets `iter` to be the parent of `child`.
             *
             * If `child` is at the toplevel, and doesn’t have a parent, then
             * `iter` is set to an invalid iterator and %FALSE is returned.
             * `child` will remain a valid node after this function has been
             * called.
             *
             * `iter` will be initialized before the lookup is performed, so `child`
             * and `iter` cannot point to the same memory location.
             * @param child the `GtkTreeIter`
             */
            vfunc_iter_parent(child: TreeIter): [boolean, TreeIter];
            /**
             * Sets `iter` to point to the previous node at the current level.
             *
             * If there is no previous `iter,` %FALSE is returned and `iter` is
             * set to be invalid.
             * @param iter the `GtkTreeIter`
             */
            vfunc_iter_previous(iter: TreeIter): boolean;
            /**
             * Lets the tree ref the node.
             *
             * This is an optional method for models to implement.
             * To be more specific, models may ignore this call as it exists
             * primarily for performance reasons.
             *
             * This function is primarily meant as a way for views to let
             * caching models know when nodes are being displayed (and hence,
             * whether or not to cache that node). Being displayed means a node
             * is in an expanded branch, regardless of whether the node is currently
             * visible in the viewport. For example, a file-system based model
             * would not want to keep the entire file-hierarchy in memory,
             * just the sections that are currently being displayed by
             * every current view.
             *
             * A model should be expected to be able to get an iter independent
             * of its reffed state.
             * @param iter the `GtkTreeIter`
             */
            vfunc_ref_node(iter: TreeIter): void;
            /**
             * Emits the ::row-changed signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-changed].
             * @param path a `GtkTreePath` pointing to the changed row
             * @param iter a valid `GtkTreeIter` pointing to the changed row
             */
            vfunc_row_changed(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::row-deleted signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-deleted].
             *
             * This should be called by models after a row has been removed.
             * The location pointed to by `path` should be the location that
             * the row previously was at. It may not be a valid location anymore.
             *
             * Nodes that are deleted are not unreffed, this means that any
             * outstanding references on the deleted node should not be released.
             * @param path a `GtkTreePath` pointing to the previous location of   the deleted row
             */
            vfunc_row_deleted(path: TreePath): void;
            /**
             * Emits the ::row-has-child-toggled signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-has-child-toggled].
             *
             * This should be called by models after the child
             * state of a node changes.
             * @param path a `GtkTreePath` pointing to the changed row
             * @param iter a valid `GtkTreeIter` pointing to the changed row
             */
            vfunc_row_has_child_toggled(path: TreePath, iter: TreeIter): void;
            /**
             * Emits the ::row-inserted signal on `tree_model`.
             *
             * See [signal`Gtk`.TreeModel::row-inserted].
             * @param path a `GtkTreePath` pointing to the inserted row
             * @param iter a valid `GtkTreeIter` pointing to the inserted row
             */
            vfunc_row_inserted(path: TreePath, iter: TreeIter): void;
            /**
             * Lets the tree unref the node.
             *
             * This is an optional method for models to implement.
             * To be more specific, models may ignore this call as it exists
             * primarily for performance reasons. For more information on what
             * this means, see gtk_tree_model_ref_node().
             *
             * Please note that nodes that are deleted are not unreffed.
             * @param iter the `GtkTreeIter`
             */
            vfunc_unref_node(iter: TreeIter): void;
        }

        export const TreeModel: TreeModelNamespace & {
            new (): TreeModel; // This allows `obj instanceof TreeModel`
        };

        namespace TreeSortable {
            // Constructor properties interface

            interface ConstructorProps extends TreeModel.ConstructorProps {}
        }

        export interface TreeSortableNamespace {
            $gtype: GObject.GType<TreeSortable>;
            prototype: TreeSortable;
        }
        interface TreeSortable extends TreeModel {
            // Methods

            /**
             * Fills in `sort_column_id` and `order` with the current sort column and the
             * order. It returns %TRUE unless the `sort_column_id` is
             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
             * @returns %TRUE if the sort column is not one of the special sort   column ids.
             */
            get_sort_column_id(): [boolean, number, SortType];
            /**
             * Returns %TRUE if the model has a default sort function. This is used
             * primarily by GtkTreeViewColumns in order to determine if a model can
             * go back to the default state, or not.
             * @returns %TRUE, if the model has a default sort function
             */
            has_default_sort_func(): boolean;
            /**
             * Sets the default comparison function used when sorting to be `sort_func`.
             * If the current sort column id of `sortable` is
             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
             * this function.
             *
             * If `sort_func` is %NULL, then there will be no default comparison function.
             * This means that once the model  has been sorted, it can’t go back to the
             * default state. In this case, when the current sort column id of `sortable`
             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
             * @param sort_func The comparison function
             * @param destroy Destroy notifier of @user_data
             */
            set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
            /**
             * Sets the current sort column to be `sort_column_id`. The `sortable` will
             * resort itself to reflect this change, after emitting a
             * `GtkTreeSortable::sort-column-changed` signal. `sort_column_id` may either be
             * a regular column id, or one of the following special values:
             *
             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
             *   will be used, if it is set
             *
             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
             * @param sort_column_id the sort column id to set
             * @param order The sort order of the column
             */
            set_sort_column_id(sort_column_id: number, order: SortType | null): void;
            /**
             * Sets the comparison function used when sorting to be `sort_func`. If the
             * current sort column id of `sortable` is the same as `sort_column_id,` then
             * the model will sort using this function.
             * @param sort_column_id the sort column id to set the function for
             * @param sort_func The comparison function
             * @param destroy Destroy notifier of @user_data
             */
            set_sort_func(
                sort_column_id: number,
                sort_func: TreeIterCompareFunc,
                destroy?: GLib.DestroyNotify | null,
            ): void;
            /**
             * Emits a `GtkTreeSortable::sort-column-changed` signal on `sortable`.
             */
            sort_column_changed(): void;

            // Virtual methods

            /**
             * Fills in `sort_column_id` and `order` with the current sort column and the
             * order. It returns %TRUE unless the `sort_column_id` is
             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
             */
            vfunc_get_sort_column_id(): [boolean, number, SortType];
            /**
             * Returns %TRUE if the model has a default sort function. This is used
             * primarily by GtkTreeViewColumns in order to determine if a model can
             * go back to the default state, or not.
             */
            vfunc_has_default_sort_func(): boolean;
            /**
             * Sets the default comparison function used when sorting to be `sort_func`.
             * If the current sort column id of `sortable` is
             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
             * this function.
             *
             * If `sort_func` is %NULL, then there will be no default comparison function.
             * This means that once the model  has been sorted, it can’t go back to the
             * default state. In this case, when the current sort column id of `sortable`
             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
             * @param sort_func The comparison function
             * @param destroy Destroy notifier of @user_data
             */
            vfunc_set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
            /**
             * Sets the current sort column to be `sort_column_id`. The `sortable` will
             * resort itself to reflect this change, after emitting a
             * `GtkTreeSortable::sort-column-changed` signal. `sort_column_id` may either be
             * a regular column id, or one of the following special values:
             *
             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
             *   will be used, if it is set
             *
             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
             * @param sort_column_id the sort column id to set
             * @param order The sort order of the column
             */
            vfunc_set_sort_column_id(sort_column_id: number, order: SortType): void;
            /**
             * Sets the comparison function used when sorting to be `sort_func`. If the
             * current sort column id of `sortable` is the same as `sort_column_id,` then
             * the model will sort using this function.
             * @param sort_column_id the sort column id to set the function for
             * @param sort_func The comparison function
             * @param destroy Destroy notifier of @user_data
             */
            vfunc_set_sort_func(
                sort_column_id: number,
                sort_func: TreeIterCompareFunc,
                destroy?: GLib.DestroyNotify | null,
            ): void;
            /**
             * Emits a `GtkTreeSortable::sort-column-changed` signal on `sortable`.
             */
            vfunc_sort_column_changed(): void;
        }

        export const TreeSortable: TreeSortableNamespace & {
            new (): TreeSortable; // This allows `obj instanceof TreeSortable`
        };

        type Allocation = Gdk.Rectangle;
        /**
         * Name of the imported GIR library
         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
         */
        const __name__: string;
        /**
         * Version of the imported GIR library
         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
         */
        const __version__: string;
    }

    export default Gtk;
}

declare module 'gi://Gtk' {
    import Gtk40 from 'gi://Gtk?version=4.0';
    export default Gtk40;
}
// END
